1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.69 for OpenJDK jdk8.
   4 #
   5 # Report bugs to <build-dev@openjdk.java.net>.
   6 #
   7 #
   8 # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
   9 #
  10 #
  11 # This configure script is free software; the Free Software Foundation
  12 # gives unlimited permission to copy, distribute and modify it.
  13 ## -------------------- ##
  14 ## M4sh Initialization. ##
  15 ## -------------------- ##
  16 
  17 # Be more Bourne compatible
  18 DUALCASE=1; export DUALCASE # for MKS sh
  19 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
  20   emulate sh
  21   NULLCMD=:
  22   # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  23   # is contrary to our usage.  Disable this feature.
  24   alias -g '${1+"$@"}'='"$@"'
  25   setopt NO_GLOB_SUBST
  26 else
  27   case `(set -o) 2>/dev/null` in #(
  28   *posix*) :
  29     set -o posix ;; #(
  30   *) :
  31      ;;
  32 esac
  33 fi
  34 
  35 
  36 as_nl='
  37 '
  38 export as_nl
  39 # Printing a long string crashes Solaris 7 /usr/bin/printf.
  40 as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
  41 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
  42 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
  43 # Prefer a ksh shell builtin over an external printf program on Solaris,
  44 # but without wasting forks for bash or zsh.
  45 if test -z "$BASH_VERSION$ZSH_VERSION" \
  46     && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
  47   as_echo='print -r --'
  48   as_echo_n='print -rn --'
  49 elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  50   as_echo='printf %s\n'
  51   as_echo_n='printf %s'
  52 else
  53   if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
  54     as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
  55     as_echo_n='/usr/ucb/echo -n'
  56   else
  57     as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
  58     as_echo_n_body='eval
  59       arg=$1;
  60       case $arg in #(
  61       *"$as_nl"*)
  62         expr "X$arg" : "X\\(.*\\)$as_nl";
  63         arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
  64       esac;
  65       expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
  66     '
  67     export as_echo_n_body
  68     as_echo_n='sh -c $as_echo_n_body as_echo'
  69   fi
  70   export as_echo_body
  71   as_echo='sh -c $as_echo_body as_echo'
  72 fi
  73 
  74 # The user is always right.
  75 if test "${PATH_SEPARATOR+set}" != set; then
  76   PATH_SEPARATOR=:
  77   (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
  78     (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
  79       PATH_SEPARATOR=';'
  80   }
  81 fi
  82 
  83 
  84 # IFS
  85 # We need space, tab and new line, in precisely that order.  Quoting is
  86 # there to prevent editors from complaining about space-tab.
  87 # (If _AS_PATH_WALK were called with IFS unset, it would disable word
  88 # splitting by setting IFS to empty value.)
  89 IFS=" ""        $as_nl"
  90 
  91 # Find who we are.  Look in the path if we contain no directory separator.
  92 as_myself=
  93 case $0 in #((
  94   *[\\/]* ) as_myself=$0 ;;
  95   *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  96 for as_dir in $PATH
  97 do
  98   IFS=$as_save_IFS
  99   test -z "$as_dir" && as_dir=.
 100     test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 101   done
 102 IFS=$as_save_IFS
 103 
 104      ;;
 105 esac
 106 # We did not find ourselves, most probably we were run as `sh COMMAND'
 107 # in which case we are not to be found in the path.
 108 if test "x$as_myself" = x; then
 109   as_myself=$0
 110 fi
 111 if test ! -f "$as_myself"; then
 112   $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
 113   exit 1
 114 fi
 115 
 116 # Unset variables that we do not need and which cause bugs (e.g. in
 117 # pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
 118 # suppresses any "Segmentation fault" message there.  '((' could
 119 # trigger a bug in pdksh 5.2.14.
 120 for as_var in BASH_ENV ENV MAIL MAILPATH
 121 do eval test x\${$as_var+set} = xset \
 122   && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
 123 done
 124 PS1='$ '
 125 PS2='> '
 126 PS4='+ '
 127 
 128 # NLS nuisances.
 129 LC_ALL=C
 130 export LC_ALL
 131 LANGUAGE=C
 132 export LANGUAGE
 133 
 134 # CDPATH.
 135 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
 136 
 137 # Use a proper internal environment variable to ensure we don't fall
 138   # into an infinite loop, continuously re-executing ourselves.
 139   if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
 140     _as_can_reexec=no; export _as_can_reexec;
 141     # We cannot yet assume a decent shell, so we have to provide a
 142 # neutralization value for shells without unset; and this also
 143 # works around shells that cannot unset nonexistent variables.
 144 # Preserve -v and -x to the replacement shell.
 145 BASH_ENV=/dev/null
 146 ENV=/dev/null
 147 (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
 148 case $- in # ((((
 149   *v*x* | *x*v* ) as_opts=-vx ;;
 150   *v* ) as_opts=-v ;;
 151   *x* ) as_opts=-x ;;
 152   * ) as_opts= ;;
 153 esac
 154 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
 155 # Admittedly, this is quite paranoid, since all the known shells bail
 156 # out after a failed `exec'.
 157 $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
 158 as_fn_exit 255
 159   fi
 160   # We don't want this to propagate to other subprocesses.
 161           { _as_can_reexec=; unset _as_can_reexec;}
 162 if test "x$CONFIG_SHELL" = x; then
 163   as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
 164   emulate sh
 165   NULLCMD=:
 166   # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
 167   # is contrary to our usage.  Disable this feature.
 168   alias -g '\${1+\"\$@\"}'='\"\$@\"'
 169   setopt NO_GLOB_SUBST
 170 else
 171   case \`(set -o) 2>/dev/null\` in #(
 172   *posix*) :
 173     set -o posix ;; #(
 174   *) :
 175      ;;
 176 esac
 177 fi
 178 "
 179   as_required="as_fn_return () { (exit \$1); }
 180 as_fn_success () { as_fn_return 0; }
 181 as_fn_failure () { as_fn_return 1; }
 182 as_fn_ret_success () { return 0; }
 183 as_fn_ret_failure () { return 1; }
 184 
 185 exitcode=0
 186 as_fn_success || { exitcode=1; echo as_fn_success failed.; }
 187 as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
 188 as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
 189 as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
 190 if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
 191 
 192 else
 193   exitcode=1; echo positional parameters were not saved.
 194 fi
 195 test x\$exitcode = x0 || exit 1
 196 test -x / || exit 1"
 197   as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
 198   as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
 199   eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
 200   test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
 201 test \$(( 1 + 1 )) = 2 || exit 1"
 202   if (eval "$as_required") 2>/dev/null; then :
 203   as_have_required=yes
 204 else
 205   as_have_required=no
 206 fi
 207   if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
 208 
 209 else
 210   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 211 as_found=false
 212 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 213 do
 214   IFS=$as_save_IFS
 215   test -z "$as_dir" && as_dir=.
 216   as_found=:
 217   case $as_dir in #(
 218          /*)
 219            for as_base in sh bash ksh sh5; do
 220              # Try only shells that exist, to save several forks.
 221              as_shell=$as_dir/$as_base
 222              if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
 223                     { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
 224   CONFIG_SHELL=$as_shell as_have_required=yes
 225                    if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
 226   break 2
 227 fi
 228 fi
 229            done;;
 230        esac
 231   as_found=false
 232 done
 233 $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
 234               { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
 235   CONFIG_SHELL=$SHELL as_have_required=yes
 236 fi; }
 237 IFS=$as_save_IFS
 238 
 239 
 240       if test "x$CONFIG_SHELL" != x; then :
 241   export CONFIG_SHELL
 242              # We cannot yet assume a decent shell, so we have to provide a
 243 # neutralization value for shells without unset; and this also
 244 # works around shells that cannot unset nonexistent variables.
 245 # Preserve -v and -x to the replacement shell.
 246 BASH_ENV=/dev/null
 247 ENV=/dev/null
 248 (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
 249 case $- in # ((((
 250   *v*x* | *x*v* ) as_opts=-vx ;;
 251   *v* ) as_opts=-v ;;
 252   *x* ) as_opts=-x ;;
 253   * ) as_opts= ;;
 254 esac
 255 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
 256 # Admittedly, this is quite paranoid, since all the known shells bail
 257 # out after a failed `exec'.
 258 $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
 259 exit 255
 260 fi
 261 
 262     if test x$as_have_required = xno; then :
 263   $as_echo "$0: This script requires a shell more modern than all"
 264   $as_echo "$0: the shells that I found on your system."
 265   if test x${ZSH_VERSION+set} = xset ; then
 266     $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
 267     $as_echo "$0: be upgraded to zsh 4.3.4 or later."
 268   else
 269     $as_echo "$0: Please tell bug-autoconf@gnu.org and
 270 $0: build-dev@openjdk.java.net about your system, including
 271 $0: any error possibly output before this message. Then
 272 $0: install a modern shell, or manually run the script
 273 $0: under such a shell if you do have one."
 274   fi
 275   exit 1
 276 fi
 277 fi
 278 fi
 279 SHELL=${CONFIG_SHELL-/bin/sh}
 280 export SHELL
 281 # Unset more variables known to interfere with behavior of common tools.
 282 CLICOLOR_FORCE= GREP_OPTIONS=
 283 unset CLICOLOR_FORCE GREP_OPTIONS
 284 
 285 ## --------------------- ##
 286 ## M4sh Shell Functions. ##
 287 ## --------------------- ##
 288 # as_fn_unset VAR
 289 # ---------------
 290 # Portably unset VAR.
 291 as_fn_unset ()
 292 {
 293   { eval $1=; unset $1;}
 294 }
 295 as_unset=as_fn_unset
 296 
 297 # as_fn_set_status STATUS
 298 # -----------------------
 299 # Set $? to STATUS, without forking.
 300 as_fn_set_status ()
 301 {
 302   return $1
 303 } # as_fn_set_status
 304 
 305 # as_fn_exit STATUS
 306 # -----------------
 307 # Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
 308 as_fn_exit ()
 309 {
 310   set +e
 311   as_fn_set_status $1
 312   exit $1
 313 } # as_fn_exit
 314 
 315 # as_fn_mkdir_p
 316 # -------------
 317 # Create "$as_dir" as a directory, including parents if necessary.
 318 as_fn_mkdir_p ()
 319 {
 320 
 321   case $as_dir in #(
 322   -*) as_dir=./$as_dir;;
 323   esac
 324   test -d "$as_dir" || eval $as_mkdir_p || {
 325     as_dirs=
 326     while :; do
 327       case $as_dir in #(
 328       *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
 329       *) as_qdir=$as_dir;;
 330       esac
 331       as_dirs="'$as_qdir' $as_dirs"
 332       as_dir=`$as_dirname -- "$as_dir" ||
 333 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 334          X"$as_dir" : 'X\(//\)[^/]' \| \
 335          X"$as_dir" : 'X\(//\)$' \| \
 336          X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
 337 $as_echo X"$as_dir" |
 338     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
 339             s//\1/
 340             q
 341           }
 342           /^X\(\/\/\)[^/].*/{
 343             s//\1/
 344             q
 345           }
 346           /^X\(\/\/\)$/{
 347             s//\1/
 348             q
 349           }
 350           /^X\(\/\).*/{
 351             s//\1/
 352             q
 353           }
 354           s/.*/./; q'`
 355       test -d "$as_dir" && break
 356     done
 357     test -z "$as_dirs" || eval "mkdir $as_dirs"
 358   } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
 359 
 360 
 361 } # as_fn_mkdir_p
 362 
 363 # as_fn_executable_p FILE
 364 # -----------------------
 365 # Test if FILE is an executable regular file.
 366 as_fn_executable_p ()
 367 {
 368   test -f "$1" && test -x "$1"
 369 } # as_fn_executable_p
 370 # as_fn_append VAR VALUE
 371 # ----------------------
 372 # Append the text in VALUE to the end of the definition contained in VAR. Take
 373 # advantage of any shell optimizations that allow amortized linear growth over
 374 # repeated appends, instead of the typical quadratic growth present in naive
 375 # implementations.
 376 if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
 377   eval 'as_fn_append ()
 378   {
 379     eval $1+=\$2
 380   }'
 381 else
 382   as_fn_append ()
 383   {
 384     eval $1=\$$1\$2
 385   }
 386 fi # as_fn_append
 387 
 388 # as_fn_arith ARG...
 389 # ------------------
 390 # Perform arithmetic evaluation on the ARGs, and store the result in the
 391 # global $as_val. Take advantage of shells that can avoid forks. The arguments
 392 # must be portable across $(()) and expr.
 393 if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
 394   eval 'as_fn_arith ()
 395   {
 396     as_val=$(( $* ))
 397   }'
 398 else
 399   as_fn_arith ()
 400   {
 401     as_val=`expr "$@" || test $? -eq 1`
 402   }
 403 fi # as_fn_arith
 404 
 405 
 406 # as_fn_error STATUS ERROR [LINENO LOG_FD]
 407 # ----------------------------------------
 408 # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
 409 # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
 410 # script with STATUS, using 1 if that was 0.
 411 as_fn_error ()
 412 {
 413   as_status=$1; test $as_status -eq 0 && as_status=1
 414   if test "$4"; then
 415     as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
 416     $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
 417   fi
 418   $as_echo "$as_me: error: $2" >&2
 419   as_fn_exit $as_status
 420 } # as_fn_error
 421 
 422 if expr a : '\(a\)' >/dev/null 2>&1 &&
 423    test "X`expr 00001 : '.*\(...\)'`" = X001; then
 424   as_expr=expr
 425 else
 426   as_expr=false
 427 fi
 428 
 429 if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
 430   as_basename=basename
 431 else
 432   as_basename=false
 433 fi
 434 
 435 if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
 436   as_dirname=dirname
 437 else
 438   as_dirname=false
 439 fi
 440 
 441 as_me=`$as_basename -- "$0" ||
 442 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
 443          X"$0" : 'X\(//\)$' \| \
 444          X"$0" : 'X\(/\)' \| . 2>/dev/null ||
 445 $as_echo X/"$0" |
 446     sed '/^.*\/\([^/][^/]*\)\/*$/{
 447             s//\1/
 448             q
 449           }
 450           /^X\/\(\/\/\)$/{
 451             s//\1/
 452             q
 453           }
 454           /^X\/\(\/\).*/{
 455             s//\1/
 456             q
 457           }
 458           s/.*/./; q'`
 459 
 460 # Avoid depending upon Character Ranges.
 461 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
 462 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 463 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
 464 as_cr_digits='0123456789'
 465 as_cr_alnum=$as_cr_Letters$as_cr_digits
 466 
 467 
 468   as_lineno_1=$LINENO as_lineno_1a=$LINENO
 469   as_lineno_2=$LINENO as_lineno_2a=$LINENO
 470   eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
 471   test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
 472   # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
 473   sed -n '
 474     p
 475     /[$]LINENO/=
 476   ' <$as_myself |
 477     sed '
 478       s/[$]LINENO.*/&-/
 479       t lineno
 480       b
 481       :lineno
 482       N
 483       :loop
 484       s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
 485       t loop
 486       s/-\n.*//
 487     ' >$as_me.lineno &&
 488   chmod +x "$as_me.lineno" ||
 489     { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
 490 
 491   # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
 492   # already done that, so ensure we don't try to do so again and fall
 493   # in an infinite loop.  This has already happened in practice.
 494   _as_can_reexec=no; export _as_can_reexec
 495   # Don't try to exec as it changes $[0], causing all sort of problems
 496   # (the dirname of $[0] is not the place where we might find the
 497   # original and so on.  Autoconf is especially sensitive to this).
 498   . "./$as_me.lineno"
 499   # Exit status is that of the last command.
 500   exit
 501 }
 502 
 503 ECHO_C= ECHO_N= ECHO_T=
 504 case `echo -n x` in #(((((
 505 -n*)
 506   case `echo 'xy\c'` in
 507   *c*) ECHO_T=' ';;     # ECHO_T is single tab character.
 508   xy)  ECHO_C='\c';;
 509   *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
 510        ECHO_T=' ';;
 511   esac;;
 512 *)
 513   ECHO_N='-n';;
 514 esac
 515 
 516 rm -f conf$$ conf$$.exe conf$$.file
 517 if test -d conf$$.dir; then
 518   rm -f conf$$.dir/conf$$.file
 519 else
 520   rm -f conf$$.dir
 521   mkdir conf$$.dir 2>/dev/null
 522 fi
 523 if (echo >conf$$.file) 2>/dev/null; then
 524   if ln -s conf$$.file conf$$ 2>/dev/null; then
 525     as_ln_s='ln -s'
 526     # ... but there are two gotchas:
 527     # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
 528     # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
 529     # In both cases, we have to default to `cp -pR'.
 530     ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
 531       as_ln_s='cp -pR'
 532   elif ln conf$$.file conf$$ 2>/dev/null; then
 533     as_ln_s=ln
 534   else
 535     as_ln_s='cp -pR'
 536   fi
 537 else
 538   as_ln_s='cp -pR'
 539 fi
 540 rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
 541 rmdir conf$$.dir 2>/dev/null
 542 
 543 if mkdir -p . 2>/dev/null; then
 544   as_mkdir_p='mkdir -p "$as_dir"'
 545 else
 546   test -d ./-p && rmdir ./-p
 547   as_mkdir_p=false
 548 fi
 549 
 550 as_test_x='test -x'
 551 as_executable_p=as_fn_executable_p
 552 
 553 # Sed expression to map a string onto a valid CPP name.
 554 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 555 
 556 # Sed expression to map a string onto a valid variable name.
 557 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 558 
 559 
 560 test -n "$DJDIR" || exec 7<&0 </dev/null
 561 exec 6>&1
 562 
 563 # Name of the host.
 564 # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
 565 # so uname gets run too.
 566 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 567 
 568 #
 569 # Initializations.
 570 #
 571 ac_default_prefix=/usr/local
 572 ac_clean_files=
 573 ac_config_libobj_dir=.
 574 LIBOBJS=
 575 cross_compiling=no
 576 subdirs=
 577 MFLAGS=
 578 MAKEFLAGS=
 579 
 580 # Identity of this package.
 581 PACKAGE_NAME='OpenJDK'
 582 PACKAGE_TARNAME='openjdk'
 583 PACKAGE_VERSION='jdk8'
 584 PACKAGE_STRING='OpenJDK jdk8'
 585 PACKAGE_BUGREPORT='build-dev@openjdk.java.net'
 586 PACKAGE_URL='http://openjdk.java.net'
 587 
 588 # Factoring default headers for most tests.
 589 ac_includes_default="\
 590 #include <stdio.h>
 591 #ifdef HAVE_SYS_TYPES_H
 592 # include <sys/types.h>
 593 #endif
 594 #ifdef HAVE_SYS_STAT_H
 595 # include <sys/stat.h>
 596 #endif
 597 #ifdef STDC_HEADERS
 598 # include <stdlib.h>
 599 # include <stddef.h>
 600 #else
 601 # ifdef HAVE_STDLIB_H
 602 #  include <stdlib.h>
 603 # endif
 604 #endif
 605 #ifdef HAVE_STRING_H
 606 # if !defined STDC_HEADERS && defined HAVE_MEMORY_H
 607 #  include <memory.h>
 608 # endif
 609 # include <string.h>
 610 #endif
 611 #ifdef HAVE_STRINGS_H
 612 # include <strings.h>
 613 #endif
 614 #ifdef HAVE_INTTYPES_H
 615 # include <inttypes.h>
 616 #endif
 617 #ifdef HAVE_STDINT_H
 618 # include <stdint.h>
 619 #endif
 620 #ifdef HAVE_UNISTD_H
 621 # include <unistd.h>
 622 #endif"
 623 
 624 ac_subst_vars='LTLIBOBJS
 625 LIBOBJS
 626 CCACHE
 627 USE_PRECOMPILED_HEADER
 628 SJAVAC_SERVER_DIR
 629 ENABLE_SJAVAC
 630 SJAVAC_SERVER_JAVA
 631 JOBS
 632 MEMORY_SIZE
 633 NUM_CORES
 634 ENABLE_INTREE_EC
 635 SALIB_NAME
 636 HOTSPOT_MAKE_ARGS
 637 LIBCXX
 638 LLVM_LIBS
 639 LLVM_LDFLAGS
 640 LLVM_CFLAGS
 641 LLVM_CONFIG
 642 LIBFFI_LIBS
 643 LIBFFI_CFLAGS
 644 STATIC_CXX_SETTING
 645 LIBDL
 646 LIBM
 647 LIBZIP_CAN_USE_MMAP
 648 USE_EXTERNAL_LIBZ



 649 USE_EXTERNAL_LIBGIF
 650 USE_EXTERNAL_LIBJPEG
 651 ALSA_LIBS
 652 ALSA_CFLAGS
 653 FREETYPE_BUNDLE_LIB_PATH
 654 FREETYPE_LIBS
 655 FREETYPE_CFLAGS
 656 CUPS_CFLAGS
 657 OPENWIN_HOME
 658 X_EXTRA_LIBS
 659 X_LIBS
 660 X_PRE_LIBS
 661 X_CFLAGS
 662 XMKMF
 663 FIXPATH
 664 CXXFLAGS_DEBUG_SYMBOLS
 665 CFLAGS_DEBUG_SYMBOLS
 666 ZIP_DEBUGINFO_FILES
 667 ENABLE_DEBUG_SYMBOLS
 668 USING_BROKEN_SUSE_LD
 669 COMPILER_SUPPORTS_TARGET_BITS_FLAG
 670 ZERO_ARCHFLAG
 671 LDFLAGS_CXX_JDK
 672 LDFLAGS_JDKEXE_SUFFIX
 673 LDFLAGS_JDKLIB_SUFFIX
 674 LDFLAGS_JDKEXE
 675 LDFLAGS_JDKLIB
 676 CXXFLAGS_JDKEXE
 677 CXXFLAGS_JDKLIB
 678 CFLAGS_JDKEXE
 679 CFLAGS_JDKLIB
 680 MACOSX_VERSION_MIN
 681 PACKAGE_PATH
 682 LEGACY_EXTRA_LDFLAGS
 683 LEGACY_EXTRA_CXXFLAGS
 684 LEGACY_EXTRA_CFLAGS
 685 CXX_FLAG_DEPS
 686 C_FLAG_DEPS
 687 CXX_O_FLAG_NONE
 688 CXX_O_FLAG_NORM
 689 CXX_O_FLAG_HI
 690 CXX_O_FLAG_HIGHEST
 691 C_O_FLAG_NONE
 692 C_O_FLAG_NORM
 693 C_O_FLAG_HI
 694 C_O_FLAG_HIGHEST
 695 POST_MCS_CMD
 696 POST_STRIP_CMD
 697 SET_EXECUTABLE_ORIGIN
 698 SET_SHARED_LIBRARY_ORIGIN
 699 CXX_FLAG_REORDER
 700 C_FLAG_REORDER
 701 SET_SHARED_LIBRARY_MAPFILE
 702 SET_SHARED_LIBRARY_NAME
 703 SHARED_LIBRARY_FLAGS
 704 EXE_SUFFIX
 705 STATIC_LIBRARY_SUFFIX
 706 SHARED_LIBRARY_SUFFIX
 707 LIBRARY_PREFIX
 708 STATIC_LIBRARY
 709 SHARED_LIBRARY
 710 OBJ_SUFFIX
 711 COMPILER_NAME
 712 JT_HOME
 713 JTREGEXE
 714 LIPO
 715 ac_ct_OBJDUMP
 716 OBJDUMP
 717 ac_ct_OBJCOPY
 718 OBJCOPY
 719 ac_ct_STRIP
 720 ac_ct_NM
 721 MCS
 722 STRIP
 723 GNM
 724 NM
 725 AS
 726 CXXCPP
 727 CPP
 728 COMPILER_TYPE
 729 RC_FLAGS
 730 DUMPBIN
 731 WINAR
 732 HOTSPOT_RC
 733 HOTSPOT_MT
 734 RC
 735 MT
 736 WINLD
 737 HOTSPOT_LD
 738 HOTSPOT_CXX
 739 ARFLAGS
 740 ac_ct_AR
 741 AR
 742 LDEXECXX
 743 LDCXX
 744 LDEXE
 745 LD
 746 ac_ct_OBJC
 747 OBJCFLAGS
 748 OBJC
 749 ac_ct_CXX
 750 CXXFLAGS
 751 CXX
 752 ac_ct_PROPER_COMPILER_CXX
 753 PROPER_COMPILER_CXX
 754 TOOLS_DIR_CXX
 755 POTENTIAL_CXX
 756 COMPILER_TARGET_BITS_FLAG
 757 OBJEXT
 758 EXEEXT
 759 ac_ct_CC
 760 CPPFLAGS
 761 LDFLAGS
 762 CFLAGS
 763 CC
 764 ac_ct_PROPER_COMPILER_CC
 765 PROPER_COMPILER_CC
 766 TOOLS_DIR_CC
 767 POTENTIAL_CC
 768 BUILD_LD
 769 BUILD_CXX
 770 BUILD_CC
 771 MSVCR_DLL
 772 VS_PATH
 773 VS_LIB
 774 VS_INCLUDE
 775 CYGWIN_LINK
 776 AR_OUT_OPTION
 777 LD_OUT_OPTION
 778 EXE_OUT_OPTION
 779 CC_OUT_OPTION
 780 BUILD_HOTSPOT
 781 HOTSPOT_DIST
 782 BUILD_OUTPUT
 783 OVERRIDE_SRC_ROOT
 784 ADD_SRC_ROOT
 785 JDK_TOPDIR
 786 NASHORN_TOPDIR
 787 HOTSPOT_TOPDIR
 788 JAXWS_TOPDIR
 789 JAXP_TOPDIR
 790 CORBA_TOPDIR
 791 LANGTOOLS_TOPDIR
 792 BOOT_JDK_JVMARGS
 793 JAVAC_FLAGS
 794 BOOT_JDK_SOURCETARGET
 795 JARSIGNER
 796 NATIVE2ASCII
 797 JAR
 798 JAVAH
 799 JAVAC
 800 JAVA
 801 BOOT_JDK
 802 BOOT_TOOLSJAR
 803 BOOT_RTJAR
 804 JAVA_CHECK
 805 JAVAC_CHECK
 806 COOKED_BUILD_NUMBER
 807 JDK_VERSION
 808 COPYRIGHT_YEAR
 809 MACOSX_BUNDLE_ID_BASE
 810 MACOSX_BUNDLE_NAME_BASE
 811 COMPANY_NAME
 812 JDK_RC_PLATFORM_NAME
 813 PRODUCT_SUFFIX
 814 PRODUCT_NAME
 815 LAUNCHER_NAME
 816 MILESTONE
 817 JDK_BUILD_NUMBER
 818 JDK_UPDATE_VERSION
 819 JDK_MICRO_VERSION
 820 JDK_MINOR_VERSION
 821 JDK_MAJOR_VERSION
 822 USER_RELEASE_SUFFIX
 823 COMPRESS_JARS
 824 UNLIMITED_CRYPTO
 825 CACERTS_FILE
 826 TEST_IN_BUILD
 827 BUILD_HEADLESS
 828 SUPPORT_HEADFUL
 829 SUPPORT_HEADLESS
 830 BDEPS_FTP
 831 BDEPS_UNZIP
 832 OS_VERSION_MICRO
 833 OS_VERSION_MINOR
 834 OS_VERSION_MAJOR
 835 PKG_CONFIG
 836 CODESIGN
 837 XATTR
 838 DSYMUTIL
 839 IS_GNU_TIME
 840 TIME
 841 STAT
 842 HG
 843 READELF
 844 OTOOL
 845 LDD
 846 ZIP
 847 UNZIP
 848 FIND_DELETE
 849 MAKE
 850 CHECK_TOOLSDIR_MAKE
 851 CHECK_TOOLSDIR_GMAKE
 852 CHECK_MAKE
 853 CHECK_GMAKE
 854 PKGHANDLER
 855 OUTPUT_ROOT
 856 CONF_NAME
 857 SPEC
 858 BUILD_VARIANT_RELEASE
 859 DEBUG_CLASSFILES
 860 FASTDEBUG
 861 VARIANT
 862 DEBUG_LEVEL
 863 MACOSX_UNIVERSAL
 864 INCLUDE_SA
 865 JVM_VARIANT_CORE
 866 JVM_VARIANT_ZEROSHARK
 867 JVM_VARIANT_ZERO
 868 JVM_VARIANT_KERNEL
 869 JVM_VARIANT_MINIMAL1
 870 JVM_VARIANT_CLIENT
 871 JVM_VARIANT_SERVER
 872 JVM_VARIANTS
 873 JVM_INTERPRETER
 874 JDK_VARIANT
 875 SET_OPENJDK
 876 BUILD_LOG_WRAPPER
 877 BUILD_LOG_PREVIOUS
 878 BUILD_LOG
 879 SYS_ROOT
 880 PATH_SEP
 881 SRC_ROOT
 882 ZERO_ARCHDEF
 883 DEFINE_CROSS_COMPILE_ARCH
 884 LP64
 885 OPENJDK_TARGET_OS_EXPORT_DIR
 886 OPENJDK_TARGET_OS_API_DIR
 887 OPENJDK_TARGET_CPU_JLI_CFLAGS
 888 OPENJDK_TARGET_CPU_OSARCH
 889 OPENJDK_TARGET_CPU_ISADIR
 890 OPENJDK_TARGET_CPU_LIBDIR
 891 OPENJDK_TARGET_CPU_LEGACY_LIB
 892 OPENJDK_TARGET_CPU_LEGACY
 893 REQUIRED_OS_VERSION
 894 REQUIRED_OS_NAME
 895 COMPILE_TYPE
 896 OPENJDK_TARGET_CPU_ENDIAN
 897 OPENJDK_TARGET_CPU_BITS
 898 OPENJDK_TARGET_CPU_ARCH
 899 OPENJDK_TARGET_CPU
 900 OPENJDK_TARGET_OS_API
 901 OPENJDK_TARGET_OS
 902 OPENJDK_BUILD_CPU_ENDIAN
 903 OPENJDK_BUILD_CPU_BITS
 904 OPENJDK_BUILD_CPU_ARCH
 905 OPENJDK_BUILD_CPU
 906 OPENJDK_BUILD_OS_API
 907 OPENJDK_BUILD_OS
 908 OPENJDK_BUILD_AUTOCONF_NAME
 909 OPENJDK_TARGET_AUTOCONF_NAME
 910 target_os
 911 target_vendor
 912 target_cpu
 913 target
 914 host_os
 915 host_vendor
 916 host_cpu
 917 host
 918 build_os
 919 build_vendor
 920 build_cpu
 921 build
 922 SETFILE
 923 DF
 924 READLINK
 925 CYGPATH
 926 SED
 927 FGREP
 928 EGREP
 929 GREP
 930 AWK
 931 XARGS
 932 WHICH
 933 WC
 934 UNIQ
 935 UNAME
 936 TR
 937 TOUCH
 938 TEE
 939 TAR
 940 TAIL
 941 SORT
 942 SH
 943 RM
 944 PRINTF
 945 NAWK
 946 MV
 947 MKTEMP
 948 MKDIR
 949 LS
 950 LN
 951 HEAD
 952 FIND
 953 FILE
 954 EXPR
 955 ECHO
 956 DIRNAME
 957 DIFF
 958 DATE
 959 CUT
 960 CPIO
 961 CP
 962 COMM
 963 CMP
 964 CHMOD
 965 CAT
 966 BASH
 967 BASENAME
 968 DATE_WHEN_CONFIGURED
 969 CONFIGURE_COMMAND_LINE
 970 CUSTOM_MAKE_DIR
 971 target_alias
 972 host_alias
 973 build_alias
 974 LIBS
 975 ECHO_T
 976 ECHO_N
 977 ECHO_C
 978 DEFS
 979 mandir
 980 localedir
 981 libdir
 982 psdir
 983 pdfdir
 984 dvidir
 985 htmldir
 986 infodir
 987 docdir
 988 oldincludedir
 989 includedir
 990 localstatedir
 991 sharedstatedir
 992 sysconfdir
 993 datadir
 994 datarootdir
 995 libexecdir
 996 sbindir
 997 bindir
 998 program_transform_name
 999 prefix
1000 exec_prefix
1001 PACKAGE_URL
1002 PACKAGE_BUGREPORT
1003 PACKAGE_STRING
1004 PACKAGE_VERSION
1005 PACKAGE_TARNAME
1006 PACKAGE_NAME
1007 PATH_SEPARATOR
1008 SHELL'
1009 ac_subst_files=''
1010 ac_user_opts='
1011 enable_option_checking
1012 with_custom_make_dir
1013 with_target_bits
1014 with_sys_root
1015 with_tools_dir
1016 with_devkit
1017 enable_openjdk_only
1018 with_jdk_variant
1019 with_jvm_interpreter
1020 with_jvm_variants
1021 enable_debug
1022 with_debug_level
1023 with_conf_name
1024 with_builddeps_conf
1025 with_builddeps_server
1026 with_builddeps_dir
1027 with_builddeps_group
1028 enable_headful
1029 enable_hotspot_test_in_build
1030 with_cacerts_file
1031 enable_unlimited_crypto
1032 with_milestone
1033 with_update_version
1034 with_user_release_suffix
1035 with_build_number
1036 with_boot_jdk
1037 with_boot_jdk_jvmargs
1038 with_add_source_root
1039 with_override_source_root
1040 with_adds_and_overrides
1041 with_override_langtools
1042 with_override_corba
1043 with_override_jaxp
1044 with_override_jaxws
1045 with_override_hotspot
1046 with_override_nashorn
1047 with_override_jdk
1048 with_import_hotspot
1049 with_msvcr_dll
1050 with_dxsdk
1051 with_dxsdk_lib
1052 with_dxsdk_include
1053 with_jtreg
1054 with_extra_cflags
1055 with_extra_cxxflags
1056 with_extra_ldflags
1057 enable_debug_symbols
1058 enable_zip_debug_info
1059 enable_macosx_runtime_support
1060 with_x
1061 with_cups
1062 with_cups_include
1063 with_freetype
1064 with_freetype_include
1065 with_freetype_lib
1066 enable_freetype_bundling
1067 with_alsa
1068 with_alsa_include
1069 with_alsa_lib
1070 with_giflib

1071 with_zlib
1072 with_stdc__lib
1073 with_num_cores
1074 with_memory_size
1075 with_jobs
1076 with_sjavac_server_java
1077 enable_sjavac
1078 enable_precompiled_headers
1079 enable_ccache
1080 with_ccache_dir
1081 '
1082       ac_precious_vars='build_alias
1083 host_alias
1084 target_alias
1085 BASENAME
1086 BASH
1087 CAT
1088 CHMOD
1089 CMP
1090 COMM
1091 CP
1092 CPIO
1093 CUT
1094 DATE
1095 DIFF
1096 DIRNAME
1097 ECHO
1098 EXPR
1099 FILE
1100 FIND
1101 HEAD
1102 LN
1103 LS
1104 MKDIR
1105 MKTEMP
1106 MV
1107 NAWK
1108 PRINTF
1109 RM
1110 SH
1111 SORT
1112 TAIL
1113 TAR
1114 TEE
1115 TOUCH
1116 TR
1117 UNAME
1118 UNIQ
1119 WC
1120 WHICH
1121 XARGS
1122 AWK
1123 GREP
1124 EGREP
1125 FGREP
1126 SED
1127 CYGPATH
1128 READLINK
1129 DF
1130 SETFILE
1131 UNZIP
1132 ZIP
1133 LDD
1134 OTOOL
1135 READELF
1136 HG
1137 STAT
1138 TIME
1139 DSYMUTIL
1140 XATTR
1141 CODESIGN
1142 PKG_CONFIG
1143 JAVA
1144 JAVAC
1145 JAVAH
1146 JAR
1147 NATIVE2ASCII
1148 JARSIGNER
1149 BUILD_CC
1150 BUILD_CXX
1151 BUILD_LD
1152 CC
1153 CFLAGS
1154 LDFLAGS
1155 LIBS
1156 CPPFLAGS
1157 CXX
1158 CXXFLAGS
1159 CCC
1160 OBJC
1161 OBJCFLAGS
1162 AR
1163 CPP
1164 CXXCPP
1165 AS
1166 NM
1167 GNM
1168 STRIP
1169 MCS
1170 OBJCOPY
1171 OBJDUMP
1172 LIPO
1173 JTREGEXE
1174 XMKMF
1175 FREETYPE_CFLAGS
1176 FREETYPE_LIBS
1177 ALSA_CFLAGS
1178 ALSA_LIBS


1179 LIBFFI_CFLAGS
1180 LIBFFI_LIBS
1181 CCACHE'
1182 
1183 
1184 # Initialize some variables set by options.
1185 ac_init_help=
1186 ac_init_version=false
1187 ac_unrecognized_opts=
1188 ac_unrecognized_sep=
1189 # The variables have the same names as the options, with
1190 # dashes changed to underlines.
1191 cache_file=/dev/null
1192 exec_prefix=NONE
1193 no_create=
1194 no_recursion=
1195 prefix=NONE
1196 program_prefix=NONE
1197 program_suffix=NONE
1198 program_transform_name=s,x,x,
1199 silent=
1200 site=
1201 srcdir=
1202 verbose=
1203 x_includes=NONE
1204 x_libraries=NONE
1205 
1206 # Installation directory options.
1207 # These are left unexpanded so users can "make install exec_prefix=/foo"
1208 # and all the variables that are supposed to be based on exec_prefix
1209 # by default will actually change.
1210 # Use braces instead of parens because sh, perl, etc. also accept them.
1211 # (The list follows the same order as the GNU Coding Standards.)
1212 bindir='${exec_prefix}/bin'
1213 sbindir='${exec_prefix}/sbin'
1214 libexecdir='${exec_prefix}/libexec'
1215 datarootdir='${prefix}/share'
1216 datadir='${datarootdir}'
1217 sysconfdir='${prefix}/etc'
1218 sharedstatedir='${prefix}/com'
1219 localstatedir='${prefix}/var'
1220 includedir='${prefix}/include'
1221 oldincludedir='/usr/include'
1222 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
1223 infodir='${datarootdir}/info'
1224 htmldir='${docdir}'
1225 dvidir='${docdir}'
1226 pdfdir='${docdir}'
1227 psdir='${docdir}'
1228 libdir='${exec_prefix}/lib'
1229 localedir='${datarootdir}/locale'
1230 mandir='${datarootdir}/man'
1231 
1232 ac_prev=
1233 ac_dashdash=
1234 for ac_option
1235 do
1236   # If the previous option needs an argument, assign it.
1237   if test -n "$ac_prev"; then
1238     eval $ac_prev=\$ac_option
1239     ac_prev=
1240     continue
1241   fi
1242 
1243   case $ac_option in
1244   *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
1245   *=)   ac_optarg= ;;
1246   *)    ac_optarg=yes ;;
1247   esac
1248 
1249   # Accept the important Cygnus configure options, so we can diagnose typos.
1250 
1251   case $ac_dashdash$ac_option in
1252   --)
1253     ac_dashdash=yes ;;
1254 
1255   -bindir | --bindir | --bindi | --bind | --bin | --bi)
1256     ac_prev=bindir ;;
1257   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
1258     bindir=$ac_optarg ;;
1259 
1260   -build | --build | --buil | --bui | --bu)
1261     ac_prev=build_alias ;;
1262   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
1263     build_alias=$ac_optarg ;;
1264 
1265   -cache-file | --cache-file | --cache-fil | --cache-fi \
1266   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
1267     ac_prev=cache_file ;;
1268   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
1269   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
1270     cache_file=$ac_optarg ;;
1271 
1272   --config-cache | -C)
1273     cache_file=config.cache ;;
1274 
1275   -datadir | --datadir | --datadi | --datad)
1276     ac_prev=datadir ;;
1277   -datadir=* | --datadir=* | --datadi=* | --datad=*)
1278     datadir=$ac_optarg ;;
1279 
1280   -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
1281   | --dataroo | --dataro | --datar)
1282     ac_prev=datarootdir ;;
1283   -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
1284   | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
1285     datarootdir=$ac_optarg ;;
1286 
1287   -disable-* | --disable-*)
1288     ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
1289     # Reject names that are not valid shell variable names.
1290     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1291       as_fn_error $? "invalid feature name: $ac_useropt"
1292     ac_useropt_orig=$ac_useropt
1293     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1294     case $ac_user_opts in
1295       *"
1296 "enable_$ac_useropt"
1297 "*) ;;
1298       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
1299          ac_unrecognized_sep=', ';;
1300     esac
1301     eval enable_$ac_useropt=no ;;
1302 
1303   -docdir | --docdir | --docdi | --doc | --do)
1304     ac_prev=docdir ;;
1305   -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
1306     docdir=$ac_optarg ;;
1307 
1308   -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
1309     ac_prev=dvidir ;;
1310   -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
1311     dvidir=$ac_optarg ;;
1312 
1313   -enable-* | --enable-*)
1314     ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
1315     # Reject names that are not valid shell variable names.
1316     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1317       as_fn_error $? "invalid feature name: $ac_useropt"
1318     ac_useropt_orig=$ac_useropt
1319     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1320     case $ac_user_opts in
1321       *"
1322 "enable_$ac_useropt"
1323 "*) ;;
1324       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
1325          ac_unrecognized_sep=', ';;
1326     esac
1327     eval enable_$ac_useropt=\$ac_optarg ;;
1328 
1329   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
1330   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
1331   | --exec | --exe | --ex)
1332     ac_prev=exec_prefix ;;
1333   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
1334   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
1335   | --exec=* | --exe=* | --ex=*)
1336     exec_prefix=$ac_optarg ;;
1337 
1338   -gas | --gas | --ga | --g)
1339     # Obsolete; use --with-gas.
1340     with_gas=yes ;;
1341 
1342   -help | --help | --hel | --he | -h)
1343     ac_init_help=long ;;
1344   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
1345     ac_init_help=recursive ;;
1346   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
1347     ac_init_help=short ;;
1348 
1349   -host | --host | --hos | --ho)
1350     ac_prev=host_alias ;;
1351   -host=* | --host=* | --hos=* | --ho=*)
1352     host_alias=$ac_optarg ;;
1353 
1354   -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
1355     ac_prev=htmldir ;;
1356   -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
1357   | --ht=*)
1358     htmldir=$ac_optarg ;;
1359 
1360   -includedir | --includedir | --includedi | --included | --include \
1361   | --includ | --inclu | --incl | --inc)
1362     ac_prev=includedir ;;
1363   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
1364   | --includ=* | --inclu=* | --incl=* | --inc=*)
1365     includedir=$ac_optarg ;;
1366 
1367   -infodir | --infodir | --infodi | --infod | --info | --inf)
1368     ac_prev=infodir ;;
1369   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
1370     infodir=$ac_optarg ;;
1371 
1372   -libdir | --libdir | --libdi | --libd)
1373     ac_prev=libdir ;;
1374   -libdir=* | --libdir=* | --libdi=* | --libd=*)
1375     libdir=$ac_optarg ;;
1376 
1377   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
1378   | --libexe | --libex | --libe)
1379     ac_prev=libexecdir ;;
1380   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
1381   | --libexe=* | --libex=* | --libe=*)
1382     libexecdir=$ac_optarg ;;
1383 
1384   -localedir | --localedir | --localedi | --localed | --locale)
1385     ac_prev=localedir ;;
1386   -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
1387     localedir=$ac_optarg ;;
1388 
1389   -localstatedir | --localstatedir | --localstatedi | --localstated \
1390   | --localstate | --localstat | --localsta | --localst | --locals)
1391     ac_prev=localstatedir ;;
1392   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
1393   | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
1394     localstatedir=$ac_optarg ;;
1395 
1396   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
1397     ac_prev=mandir ;;
1398   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
1399     mandir=$ac_optarg ;;
1400 
1401   -nfp | --nfp | --nf)
1402     # Obsolete; use --without-fp.
1403     with_fp=no ;;
1404 
1405   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
1406   | --no-cr | --no-c | -n)
1407     no_create=yes ;;
1408 
1409   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
1410   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
1411     no_recursion=yes ;;
1412 
1413   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
1414   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
1415   | --oldin | --oldi | --old | --ol | --o)
1416     ac_prev=oldincludedir ;;
1417   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
1418   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
1419   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
1420     oldincludedir=$ac_optarg ;;
1421 
1422   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
1423     ac_prev=prefix ;;
1424   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
1425     prefix=$ac_optarg ;;
1426 
1427   -program-prefix | --program-prefix | --program-prefi | --program-pref \
1428   | --program-pre | --program-pr | --program-p)
1429     ac_prev=program_prefix ;;
1430   -program-prefix=* | --program-prefix=* | --program-prefi=* \
1431   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
1432     program_prefix=$ac_optarg ;;
1433 
1434   -program-suffix | --program-suffix | --program-suffi | --program-suff \
1435   | --program-suf | --program-su | --program-s)
1436     ac_prev=program_suffix ;;
1437   -program-suffix=* | --program-suffix=* | --program-suffi=* \
1438   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
1439     program_suffix=$ac_optarg ;;
1440 
1441   -program-transform-name | --program-transform-name \
1442   | --program-transform-nam | --program-transform-na \
1443   | --program-transform-n | --program-transform- \
1444   | --program-transform | --program-transfor \
1445   | --program-transfo | --program-transf \
1446   | --program-trans | --program-tran \
1447   | --progr-tra | --program-tr | --program-t)
1448     ac_prev=program_transform_name ;;
1449   -program-transform-name=* | --program-transform-name=* \
1450   | --program-transform-nam=* | --program-transform-na=* \
1451   | --program-transform-n=* | --program-transform-=* \
1452   | --program-transform=* | --program-transfor=* \
1453   | --program-transfo=* | --program-transf=* \
1454   | --program-trans=* | --program-tran=* \
1455   | --progr-tra=* | --program-tr=* | --program-t=*)
1456     program_transform_name=$ac_optarg ;;
1457 
1458   -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
1459     ac_prev=pdfdir ;;
1460   -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
1461     pdfdir=$ac_optarg ;;
1462 
1463   -psdir | --psdir | --psdi | --psd | --ps)
1464     ac_prev=psdir ;;
1465   -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
1466     psdir=$ac_optarg ;;
1467 
1468   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1469   | -silent | --silent | --silen | --sile | --sil)
1470     silent=yes ;;
1471 
1472   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
1473     ac_prev=sbindir ;;
1474   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
1475   | --sbi=* | --sb=*)
1476     sbindir=$ac_optarg ;;
1477 
1478   -sharedstatedir | --sharedstatedir | --sharedstatedi \
1479   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
1480   | --sharedst | --shareds | --shared | --share | --shar \
1481   | --sha | --sh)
1482     ac_prev=sharedstatedir ;;
1483   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
1484   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
1485   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
1486   | --sha=* | --sh=*)
1487     sharedstatedir=$ac_optarg ;;
1488 
1489   -site | --site | --sit)
1490     ac_prev=site ;;
1491   -site=* | --site=* | --sit=*)
1492     site=$ac_optarg ;;
1493 
1494   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
1495     ac_prev=srcdir ;;
1496   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
1497     srcdir=$ac_optarg ;;
1498 
1499   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
1500   | --syscon | --sysco | --sysc | --sys | --sy)
1501     ac_prev=sysconfdir ;;
1502   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
1503   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
1504     sysconfdir=$ac_optarg ;;
1505 
1506   -target | --target | --targe | --targ | --tar | --ta | --t)
1507     ac_prev=target_alias ;;
1508   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
1509     target_alias=$ac_optarg ;;
1510 
1511   -v | -verbose | --verbose | --verbos | --verbo | --verb)
1512     verbose=yes ;;
1513 
1514   -version | --version | --versio | --versi | --vers | -V)
1515     ac_init_version=: ;;
1516 
1517   -with-* | --with-*)
1518     ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1519     # Reject names that are not valid shell variable names.
1520     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1521       as_fn_error $? "invalid package name: $ac_useropt"
1522     ac_useropt_orig=$ac_useropt
1523     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1524     case $ac_user_opts in
1525       *"
1526 "with_$ac_useropt"
1527 "*) ;;
1528       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
1529          ac_unrecognized_sep=', ';;
1530     esac
1531     eval with_$ac_useropt=\$ac_optarg ;;
1532 
1533   -without-* | --without-*)
1534     ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1535     # Reject names that are not valid shell variable names.
1536     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1537       as_fn_error $? "invalid package name: $ac_useropt"
1538     ac_useropt_orig=$ac_useropt
1539     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1540     case $ac_user_opts in
1541       *"
1542 "with_$ac_useropt"
1543 "*) ;;
1544       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
1545          ac_unrecognized_sep=', ';;
1546     esac
1547     eval with_$ac_useropt=no ;;
1548 
1549   --x)
1550     # Obsolete; use --with-x.
1551     with_x=yes ;;
1552 
1553   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
1554   | --x-incl | --x-inc | --x-in | --x-i)
1555     ac_prev=x_includes ;;
1556   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
1557   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
1558     x_includes=$ac_optarg ;;
1559 
1560   -x-libraries | --x-libraries | --x-librarie | --x-librari \
1561   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
1562     ac_prev=x_libraries ;;
1563   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
1564   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1565     x_libraries=$ac_optarg ;;
1566 
1567   -*) as_fn_error $? "unrecognized option: \`$ac_option'
1568 Try \`$0 --help' for more information"
1569     ;;
1570 
1571   *=*)
1572     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1573     # Reject names that are not valid shell variable names.
1574     case $ac_envvar in #(
1575       '' | [0-9]* | *[!_$as_cr_alnum]* )
1576       as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1577     esac
1578     eval $ac_envvar=\$ac_optarg
1579     export $ac_envvar ;;
1580 
1581   *)
1582     # FIXME: should be removed in autoconf 3.0.
1583     $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1584     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1585       $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1586     : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1587     ;;
1588 
1589   esac
1590 done
1591 
1592 if test -n "$ac_prev"; then
1593   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1594   as_fn_error $? "missing argument to $ac_option"
1595 fi
1596 
1597 if test -n "$ac_unrecognized_opts"; then
1598   case $enable_option_checking in
1599     no) ;;
1600     fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1601     *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1602   esac
1603 fi
1604 
1605 # Check all directory arguments for consistency.
1606 for ac_var in   exec_prefix prefix bindir sbindir libexecdir datarootdir \
1607                 datadir sysconfdir sharedstatedir localstatedir includedir \
1608                 oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
1609                 libdir localedir mandir
1610 do
1611   eval ac_val=\$$ac_var
1612   # Remove trailing slashes.
1613   case $ac_val in
1614     */ )
1615       ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
1616       eval $ac_var=\$ac_val;;
1617   esac
1618   # Be sure to have absolute directory names.
1619   case $ac_val in
1620     [\\/$]* | ?:[\\/]* )  continue;;
1621     NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1622   esac
1623   as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1624 done
1625 
1626 # There might be people who depend on the old broken behavior: `$host'
1627 # used to hold the argument of --host etc.
1628 # FIXME: To remove some day.
1629 build=$build_alias
1630 host=$host_alias
1631 target=$target_alias
1632 
1633 # FIXME: To remove some day.
1634 if test "x$host_alias" != x; then
1635   if test "x$build_alias" = x; then
1636     cross_compiling=maybe
1637   elif test "x$build_alias" != "x$host_alias"; then
1638     cross_compiling=yes
1639   fi
1640 fi
1641 
1642 ac_tool_prefix=
1643 test -n "$host_alias" && ac_tool_prefix=$host_alias-
1644 
1645 test "$silent" = yes && exec 6>/dev/null
1646 
1647 
1648 ac_pwd=`pwd` && test -n "$ac_pwd" &&
1649 ac_ls_di=`ls -di .` &&
1650 ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1651   as_fn_error $? "working directory cannot be determined"
1652 test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1653   as_fn_error $? "pwd does not report name of working directory"
1654 
1655 
1656 # Find the source files, if location was not specified.
1657 if test -z "$srcdir"; then
1658   ac_srcdir_defaulted=yes
1659   # Try the directory containing this script, then the parent directory.
1660   ac_confdir=`$as_dirname -- "$as_myself" ||
1661 $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1662          X"$as_myself" : 'X\(//\)[^/]' \| \
1663          X"$as_myself" : 'X\(//\)$' \| \
1664          X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
1665 $as_echo X"$as_myself" |
1666     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
1667             s//\1/
1668             q
1669           }
1670           /^X\(\/\/\)[^/].*/{
1671             s//\1/
1672             q
1673           }
1674           /^X\(\/\/\)$/{
1675             s//\1/
1676             q
1677           }
1678           /^X\(\/\).*/{
1679             s//\1/
1680             q
1681           }
1682           s/.*/./; q'`
1683   srcdir=$ac_confdir
1684   if test ! -r "$srcdir/$ac_unique_file"; then
1685     srcdir=..
1686   fi
1687 else
1688   ac_srcdir_defaulted=no
1689 fi
1690 if test ! -r "$srcdir/$ac_unique_file"; then
1691   test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1692   as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1693 fi
1694 ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1695 ac_abs_confdir=`(
1696         cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1697         pwd)`
1698 # When building in place, set srcdir=.
1699 if test "$ac_abs_confdir" = "$ac_pwd"; then
1700   srcdir=.
1701 fi
1702 # Remove unnecessary trailing slashes from srcdir.
1703 # Double slashes in file names in object file debugging info
1704 # mess up M-x gdb in Emacs.
1705 case $srcdir in
1706 */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
1707 esac
1708 for ac_var in $ac_precious_vars; do
1709   eval ac_env_${ac_var}_set=\${${ac_var}+set}
1710   eval ac_env_${ac_var}_value=\$${ac_var}
1711   eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
1712   eval ac_cv_env_${ac_var}_value=\$${ac_var}
1713 done
1714 
1715 #
1716 # Report the --help message.
1717 #
1718 if test "$ac_init_help" = "long"; then
1719   # Omit some internal or obsolete options to make the list less imposing.
1720   # This message is too long to be a string in the A/UX 3.1 sh.
1721   cat <<_ACEOF
1722 \`configure' configures OpenJDK jdk8 to adapt to many kinds of systems.
1723 
1724 Usage: $0 [OPTION]... [VAR=VALUE]...
1725 
1726 To assign environment variables (e.g., CC, CFLAGS...), specify them as
1727 VAR=VALUE.  See below for descriptions of some of the useful variables.
1728 
1729 Defaults for the options are specified in brackets.
1730 
1731 Configuration:
1732   -h, --help              display this help and exit
1733       --help=short        display options specific to this package
1734       --help=recursive    display the short help of all the included packages
1735   -V, --version           display version information and exit
1736   -q, --quiet, --silent   do not print \`checking ...' messages
1737       --cache-file=FILE   cache test results in FILE [disabled]
1738   -C, --config-cache      alias for \`--cache-file=config.cache'
1739   -n, --no-create         do not create output files
1740       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
1741 
1742 Installation directories:
1743   --prefix=PREFIX         install architecture-independent files in PREFIX
1744                           [$ac_default_prefix]
1745   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
1746                           [PREFIX]
1747 
1748 By default, \`make install' will install all the files in
1749 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
1750 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
1751 for instance \`--prefix=\$HOME'.
1752 
1753 For better control, use the options below.
1754 
1755 Fine tuning of the installation directories:
1756   --bindir=DIR            user executables [EPREFIX/bin]
1757   --sbindir=DIR           system admin executables [EPREFIX/sbin]
1758   --libexecdir=DIR        program executables [EPREFIX/libexec]
1759   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
1760   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
1761   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
1762   --libdir=DIR            object code libraries [EPREFIX/lib]
1763   --includedir=DIR        C header files [PREFIX/include]
1764   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
1765   --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
1766   --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
1767   --infodir=DIR           info documentation [DATAROOTDIR/info]
1768   --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
1769   --mandir=DIR            man documentation [DATAROOTDIR/man]
1770   --docdir=DIR            documentation root [DATAROOTDIR/doc/openjdk]
1771   --htmldir=DIR           html documentation [DOCDIR]
1772   --dvidir=DIR            dvi documentation [DOCDIR]
1773   --pdfdir=DIR            pdf documentation [DOCDIR]
1774   --psdir=DIR             ps documentation [DOCDIR]
1775 _ACEOF
1776 
1777   cat <<\_ACEOF
1778 
1779 X features:
1780   --x-includes=DIR    X include files are in DIR
1781   --x-libraries=DIR   X library files are in DIR
1782 
1783 System types:
1784   --build=BUILD     configure for building on BUILD [guessed]
1785   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
1786   --target=TARGET   configure for building compilers for TARGET [HOST]
1787 _ACEOF
1788 fi
1789 
1790 if test -n "$ac_init_help"; then
1791   case $ac_init_help in
1792      short | recursive ) echo "Configuration of OpenJDK jdk8:";;
1793    esac
1794   cat <<\_ACEOF
1795 
1796 Optional Features:
1797   --disable-option-checking  ignore unrecognized --enable/--with options
1798   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1799   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
1800   --enable-openjdk-only   suppress building custom source even if present
1801                           [disabled]
1802   --enable-debug          set the debug level to fastdebug (shorthand for
1803                           --with-debug-level=fastdebug) [disabled]
1804   --disable-headful       disable building headful support (graphical UI
1805                           support) [enabled]
1806   --enable-hotspot-test-in-build
1807                           run the Queens test after Hotspot build [disabled]
1808   --enable-unlimited-crypto
1809                           Enable unlimited crypto policy [disabled]
1810   --disable-debug-symbols disable generation of debug symbols [enabled]
1811   --disable-zip-debug-info
1812                           disable zipping of debug-info files [enabled]
1813   --enable-macosx-runtime-support
1814                           Deprecated. Option is kept for backwards
1815                           compatibility and is ignored
1816   --disable-freetype-bundling
1817                           disable bundling of the freetype library with the
1818                           build result [enabled on Windows or when using
1819                           --with-freetype, disabled otherwise]
1820   --enable-sjavac         use sjavac to do fast incremental compiles
1821                           [disabled]
1822   --disable-precompiled-headers
1823                           disable using precompiled headers when compiling C++
1824                           [enabled]
1825   --enable-ccache         enable using ccache to speed up recompilations
1826                           [disabled]
1827 
1828 Optional Packages:
1829   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1830   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
1831   --with-custom-make-dir  use this directory for custom build/make files
1832   --with-target-bits      build 32-bit or 64-bit binaries (for platforms that
1833                           support it), e.g. --with-target-bits=32 [guessed]
1834   --with-sys-root         pass this sys-root to the compilers and tools (for
1835                           cross-compiling)
1836   --with-tools-dir        search this directory for compilers and tools (for
1837                           cross-compiling)
1838   --with-devkit           use this directory as base for tools-dir and
1839                           sys-root (for cross-compiling)
1840   --with-jdk-variant      JDK variant to build (normal) [normal]
1841   --with-jvm-interpreter  JVM interpreter to build (template, cpp) [template]
1842   --with-jvm-variants     JVM variants (separated by commas) to build (server,
1843                           client, minimal1, kernel, zero, zeroshark, core)
1844                           [server]
1845   --with-debug-level      set the debug level (release, fastdebug, slowdebug)
1846                           [release]
1847   --with-conf-name        use this as the name of the configuration [generated
1848                           from important configuration options]
1849   --with-builddeps-conf   use this configuration file for the builddeps
1850   --with-builddeps-server download and use build dependencies from this server
1851                           url
1852   --with-builddeps-dir    store downloaded build dependencies here
1853                           [/localhome/builddeps]
1854   --with-builddeps-group  chgrp the downloaded build dependencies to this
1855                           group
1856   --with-cacerts-file     specify alternative cacerts file
1857   --with-milestone        Set milestone value for build [internal]
1858   --with-update-version   Set update version value for build [b00]
1859   --with-user-release-suffix
1860                           Add a custom string to the version string if build
1861                           number isn't set.[username_builddateb00]
1862   --with-build-number     Set build number value for build [b00]
1863   --with-boot-jdk         path to Boot JDK (used to bootstrap build) [probed]
1864   --with-boot-jdk-jvmargs specify JVM arguments to be passed to all
1865                           invocations of the Boot JDK, overriding the default
1866                           values, e.g --with-boot-jdk-jvmargs="-Xmx8G
1867                           -enableassertions"
1868   --with-add-source-root  for each and every source directory, look in this
1869                           additional source root for the same directory; if it
1870                           exists and have files in it, include it in the build
1871   --with-override-source-root
1872                           for each and every source directory, look in this
1873                           override source root for the same directory; if it
1874                           exists, use that directory instead and ignore the
1875                           directory in the original source root
1876   --with-adds-and-overrides
1877                           use the subdirs 'adds' and 'overrides' in the
1878                           specified directory as add-source-root and
1879                           override-source-root
1880   --with-override-langtools
1881                           use this langtools dir for the build
1882   --with-override-corba   use this corba dir for the build
1883   --with-override-jaxp    use this jaxp dir for the build
1884   --with-override-jaxws   use this jaxws dir for the build
1885   --with-override-hotspot use this hotspot dir for the build
1886   --with-override-nashorn use this nashorn dir for the build
1887   --with-override-jdk     use this jdk dir for the build
1888   --with-import-hotspot   import hotspot binaries from this jdk image or
1889                           hotspot build dist dir instead of building from
1890                           source
1891   --with-msvcr-dll        copy this msvcr100.dll into the built JDK (Windows
1892                           only) [probed]
1893   --with-dxsdk            Deprecated. Option is kept for backwards
1894                           compatibility and is ignored
1895   --with-dxsdk-lib        Deprecated. Option is kept for backwards
1896                           compatibility and is ignored
1897   --with-dxsdk-include    Deprecated. Option is kept for backwards
1898                           compatibility and is ignored
1899   --with-jtreg            Regression Test Harness [probed]
1900   --with-extra-cflags     extra flags to be used when compiling jdk c-files
1901   --with-extra-cxxflags   extra flags to be used when compiling jdk c++-files
1902   --with-extra-ldflags    extra flags to be used when linking jdk
1903   --with-x                use the X Window System
1904   --with-cups             specify prefix directory for the cups package
1905                           (expecting the headers under PATH/include)
1906   --with-cups-include     specify directory for the cups include files
1907   --with-freetype         specify prefix directory for the freetype package
1908                           (expecting the libraries under PATH/lib and the
1909                           headers under PATH/include)
1910   --with-freetype-include specify directory for the freetype include files
1911   --with-freetype-lib     specify directory for the freetype library
1912   --with-alsa             specify prefix directory for the alsa package
1913                           (expecting the libraries under PATH/lib and the
1914                           headers under PATH/include)
1915   --with-alsa-include     specify directory for the alsa include files
1916   --with-alsa-lib         specify directory for the alsa library
1917   --with-giflib           use giflib from build system or OpenJDK source
1918                           (system, bundled) [bundled]


1919   --with-zlib             use zlib from build system or OpenJDK source
1920                           (system, bundled) [bundled]
1921   --with-stdc++lib=<static>,<dynamic>,<default>
1922                           force linking of the C++ runtime on Linux to either
1923                           static or dynamic, default is static with dynamic as
1924                           fallback
1925   --with-num-cores        number of cores in the build system, e.g.
1926                           --with-num-cores=8 [probed]
1927   --with-memory-size      memory (in MB) available in the build system, e.g.
1928                           --with-memory-size=1024 [probed]
1929   --with-jobs             number of parallel jobs to let make run [calculated
1930                           based on cores and memory]
1931   --with-sjavac-server-java
1932                           use this java binary for running the sjavac
1933                           background server [Boot JDK java]
1934   --with-ccache-dir       where to store ccache files [~/.ccache]
1935 
1936 Some influential environment variables:
1937   BASENAME    Override default value for BASENAME
1938   BASH        Override default value for BASH
1939   CAT         Override default value for CAT
1940   CHMOD       Override default value for CHMOD
1941   CMP         Override default value for CMP
1942   COMM        Override default value for COMM
1943   CP          Override default value for CP
1944   CPIO        Override default value for CPIO
1945   CUT         Override default value for CUT
1946   DATE        Override default value for DATE
1947   DIFF        Override default value for DIFF
1948   DIRNAME     Override default value for DIRNAME
1949   ECHO        Override default value for ECHO
1950   EXPR        Override default value for EXPR
1951   FILE        Override default value for FILE
1952   FIND        Override default value for FIND
1953   HEAD        Override default value for HEAD
1954   LN          Override default value for LN
1955   LS          Override default value for LS
1956   MKDIR       Override default value for MKDIR
1957   MKTEMP      Override default value for MKTEMP
1958   MV          Override default value for MV
1959   NAWK        Override default value for NAWK
1960   PRINTF      Override default value for PRINTF
1961   RM          Override default value for RM
1962   SH          Override default value for SH
1963   SORT        Override default value for SORT
1964   TAIL        Override default value for TAIL
1965   TAR         Override default value for TAR
1966   TEE         Override default value for TEE
1967   TOUCH       Override default value for TOUCH
1968   TR          Override default value for TR
1969   UNAME       Override default value for UNAME
1970   UNIQ        Override default value for UNIQ
1971   WC          Override default value for WC
1972   WHICH       Override default value for WHICH
1973   XARGS       Override default value for XARGS
1974   AWK         Override default value for AWK
1975   GREP        Override default value for GREP
1976   EGREP       Override default value for EGREP
1977   FGREP       Override default value for FGREP
1978   SED         Override default value for SED
1979   CYGPATH     Override default value for CYGPATH
1980   READLINK    Override default value for READLINK
1981   DF          Override default value for DF
1982   SETFILE     Override default value for SETFILE
1983   UNZIP       Override default value for UNZIP
1984   ZIP         Override default value for ZIP
1985   LDD         Override default value for LDD
1986   OTOOL       Override default value for OTOOL
1987   READELF     Override default value for READELF
1988   HG          Override default value for HG
1989   STAT        Override default value for STAT
1990   TIME        Override default value for TIME
1991   DSYMUTIL    Override default value for DSYMUTIL
1992   XATTR       Override default value for XATTR
1993   CODESIGN    Override default value for CODESIGN
1994   PKG_CONFIG  path to pkg-config utility
1995   JAVA        Override default value for JAVA
1996   JAVAC       Override default value for JAVAC
1997   JAVAH       Override default value for JAVAH
1998   JAR         Override default value for JAR
1999   NATIVE2ASCII
2000               Override default value for NATIVE2ASCII
2001   JARSIGNER   Override default value for JARSIGNER
2002   BUILD_CC    Override default value for BUILD_CC
2003   BUILD_CXX   Override default value for BUILD_CXX
2004   BUILD_LD    Override default value for BUILD_LD
2005   CC          C compiler command
2006   CFLAGS      C compiler flags
2007   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
2008               nonstandard directory <lib dir>
2009   LIBS        libraries to pass to the linker, e.g. -l<library>
2010   CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
2011               you have headers in a nonstandard directory <include dir>
2012   CXX         C++ compiler command
2013   CXXFLAGS    C++ compiler flags
2014   OBJC        Objective C compiler command
2015   OBJCFLAGS   Objective C compiler flags
2016   AR          Override default value for AR
2017   CPP         C preprocessor
2018   CXXCPP      C++ preprocessor
2019   AS          Override default value for AS
2020   NM          Override default value for NM
2021   GNM         Override default value for GNM
2022   STRIP       Override default value for STRIP
2023   MCS         Override default value for MCS
2024   OBJCOPY     Override default value for OBJCOPY
2025   OBJDUMP     Override default value for OBJDUMP
2026   LIPO        Override default value for LIPO
2027   JTREGEXE    Override default value for JTREGEXE
2028   XMKMF       Path to xmkmf, Makefile generator for X Window System
2029   FREETYPE_CFLAGS
2030               C compiler flags for FREETYPE, overriding pkg-config
2031   FREETYPE_LIBS
2032               linker flags for FREETYPE, overriding pkg-config
2033   ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
2034   ALSA_LIBS   linker flags for ALSA, overriding pkg-config


2035   LIBFFI_CFLAGS
2036               C compiler flags for LIBFFI, overriding pkg-config
2037   LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
2038   CCACHE      Override default value for CCACHE
2039 
2040 Use these variables to override the choices made by `configure' or to help
2041 it to find libraries and programs with nonstandard names/locations.
2042 
2043 Report bugs to <build-dev@openjdk.java.net>.
2044 OpenJDK home page: <http://openjdk.java.net>.
2045 _ACEOF
2046 ac_status=$?
2047 fi
2048 
2049 if test "$ac_init_help" = "recursive"; then
2050   # If there are subdirs, report their specific --help.
2051   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
2052     test -d "$ac_dir" ||
2053       { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
2054       continue
2055     ac_builddir=.
2056 
2057 case "$ac_dir" in
2058 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
2059 *)
2060   ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
2061   # A ".." for each directory in $ac_dir_suffix.
2062   ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
2063   case $ac_top_builddir_sub in
2064   "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
2065   *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
2066   esac ;;
2067 esac
2068 ac_abs_top_builddir=$ac_pwd
2069 ac_abs_builddir=$ac_pwd$ac_dir_suffix
2070 # for backward compatibility:
2071 ac_top_builddir=$ac_top_build_prefix
2072 
2073 case $srcdir in
2074   .)  # We are building in place.
2075     ac_srcdir=.
2076     ac_top_srcdir=$ac_top_builddir_sub
2077     ac_abs_top_srcdir=$ac_pwd ;;
2078   [\\/]* | ?:[\\/]* )  # Absolute name.
2079     ac_srcdir=$srcdir$ac_dir_suffix;
2080     ac_top_srcdir=$srcdir
2081     ac_abs_top_srcdir=$srcdir ;;
2082   *) # Relative name.
2083     ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
2084     ac_top_srcdir=$ac_top_build_prefix$srcdir
2085     ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
2086 esac
2087 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
2088 
2089     cd "$ac_dir" || { ac_status=$?; continue; }
2090     # Check for guested configure.
2091     if test -f "$ac_srcdir/configure.gnu"; then
2092       echo &&
2093       $SHELL "$ac_srcdir/configure.gnu" --help=recursive
2094     elif test -f "$ac_srcdir/configure"; then
2095       echo &&
2096       $SHELL "$ac_srcdir/configure" --help=recursive
2097     else
2098       $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
2099     fi || ac_status=$?
2100     cd "$ac_pwd" || { ac_status=$?; break; }
2101   done
2102 fi
2103 
2104 test -n "$ac_init_help" && exit $ac_status
2105 if $ac_init_version; then
2106   cat <<\_ACEOF
2107 OpenJDK configure jdk8
2108 generated by GNU Autoconf 2.69
2109 
2110 Copyright (C) 2012 Free Software Foundation, Inc.
2111 This configure script is free software; the Free Software Foundation
2112 gives unlimited permission to copy, distribute and modify it.
2113 _ACEOF
2114   exit
2115 fi
2116 
2117 ## ------------------------ ##
2118 ## Autoconf initialization. ##
2119 ## ------------------------ ##
2120 
2121 # ac_fn_c_try_compile LINENO
2122 # --------------------------
2123 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2124 ac_fn_c_try_compile ()
2125 {
2126   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2127   rm -f conftest.$ac_objext
2128   if { { ac_try="$ac_compile"
2129 case "(($ac_try" in
2130   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2131   *) ac_try_echo=$ac_try;;
2132 esac
2133 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2134 $as_echo "$ac_try_echo"; } >&5
2135   (eval "$ac_compile") 2>conftest.err
2136   ac_status=$?
2137   if test -s conftest.err; then
2138     grep -v '^ *+' conftest.err >conftest.er1
2139     cat conftest.er1 >&5
2140     mv -f conftest.er1 conftest.err
2141   fi
2142   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2143   test $ac_status = 0; } && {
2144          test -z "$ac_c_werror_flag" ||
2145          test ! -s conftest.err
2146        } && test -s conftest.$ac_objext; then :
2147   ac_retval=0
2148 else
2149   $as_echo "$as_me: failed program was:" >&5
2150 sed 's/^/| /' conftest.$ac_ext >&5
2151 
2152         ac_retval=1
2153 fi
2154   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2155   as_fn_set_status $ac_retval
2156 
2157 } # ac_fn_c_try_compile
2158 
2159 # ac_fn_cxx_try_compile LINENO
2160 # ----------------------------
2161 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2162 ac_fn_cxx_try_compile ()
2163 {
2164   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2165   rm -f conftest.$ac_objext
2166   if { { ac_try="$ac_compile"
2167 case "(($ac_try" in
2168   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2169   *) ac_try_echo=$ac_try;;
2170 esac
2171 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2172 $as_echo "$ac_try_echo"; } >&5
2173   (eval "$ac_compile") 2>conftest.err
2174   ac_status=$?
2175   if test -s conftest.err; then
2176     grep -v '^ *+' conftest.err >conftest.er1
2177     cat conftest.er1 >&5
2178     mv -f conftest.er1 conftest.err
2179   fi
2180   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2181   test $ac_status = 0; } && {
2182          test -z "$ac_cxx_werror_flag" ||
2183          test ! -s conftest.err
2184        } && test -s conftest.$ac_objext; then :
2185   ac_retval=0
2186 else
2187   $as_echo "$as_me: failed program was:" >&5
2188 sed 's/^/| /' conftest.$ac_ext >&5
2189 
2190         ac_retval=1
2191 fi
2192   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2193   as_fn_set_status $ac_retval
2194 
2195 } # ac_fn_cxx_try_compile
2196 
2197 # ac_fn_objc_try_compile LINENO
2198 # -----------------------------
2199 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2200 ac_fn_objc_try_compile ()
2201 {
2202   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2203   rm -f conftest.$ac_objext
2204   if { { ac_try="$ac_compile"
2205 case "(($ac_try" in
2206   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2207   *) ac_try_echo=$ac_try;;
2208 esac
2209 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2210 $as_echo "$ac_try_echo"; } >&5
2211   (eval "$ac_compile") 2>conftest.err
2212   ac_status=$?
2213   if test -s conftest.err; then
2214     grep -v '^ *+' conftest.err >conftest.er1
2215     cat conftest.er1 >&5
2216     mv -f conftest.er1 conftest.err
2217   fi
2218   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2219   test $ac_status = 0; } && {
2220          test -z "$ac_objc_werror_flag" ||
2221          test ! -s conftest.err
2222        } && test -s conftest.$ac_objext; then :
2223   ac_retval=0
2224 else
2225   $as_echo "$as_me: failed program was:" >&5
2226 sed 's/^/| /' conftest.$ac_ext >&5
2227 
2228         ac_retval=1
2229 fi
2230   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2231   as_fn_set_status $ac_retval
2232 
2233 } # ac_fn_objc_try_compile
2234 
2235 # ac_fn_c_try_cpp LINENO
2236 # ----------------------
2237 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2238 ac_fn_c_try_cpp ()
2239 {
2240   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2241   if { { ac_try="$ac_cpp conftest.$ac_ext"
2242 case "(($ac_try" in
2243   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2244   *) ac_try_echo=$ac_try;;
2245 esac
2246 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2247 $as_echo "$ac_try_echo"; } >&5
2248   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2249   ac_status=$?
2250   if test -s conftest.err; then
2251     grep -v '^ *+' conftest.err >conftest.er1
2252     cat conftest.er1 >&5
2253     mv -f conftest.er1 conftest.err
2254   fi
2255   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2256   test $ac_status = 0; } > conftest.i && {
2257          test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
2258          test ! -s conftest.err
2259        }; then :
2260   ac_retval=0
2261 else
2262   $as_echo "$as_me: failed program was:" >&5
2263 sed 's/^/| /' conftest.$ac_ext >&5
2264 
2265     ac_retval=1
2266 fi
2267   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2268   as_fn_set_status $ac_retval
2269 
2270 } # ac_fn_c_try_cpp
2271 
2272 # ac_fn_cxx_try_cpp LINENO
2273 # ------------------------
2274 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2275 ac_fn_cxx_try_cpp ()
2276 {
2277   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2278   if { { ac_try="$ac_cpp conftest.$ac_ext"
2279 case "(($ac_try" in
2280   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2281   *) ac_try_echo=$ac_try;;
2282 esac
2283 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2284 $as_echo "$ac_try_echo"; } >&5
2285   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2286   ac_status=$?
2287   if test -s conftest.err; then
2288     grep -v '^ *+' conftest.err >conftest.er1
2289     cat conftest.er1 >&5
2290     mv -f conftest.er1 conftest.err
2291   fi
2292   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2293   test $ac_status = 0; } > conftest.i && {
2294          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2295          test ! -s conftest.err
2296        }; then :
2297   ac_retval=0
2298 else
2299   $as_echo "$as_me: failed program was:" >&5
2300 sed 's/^/| /' conftest.$ac_ext >&5
2301 
2302     ac_retval=1
2303 fi
2304   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2305   as_fn_set_status $ac_retval
2306 
2307 } # ac_fn_cxx_try_cpp
2308 
2309 # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2310 # ---------------------------------------------------------
2311 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2312 # the include files in INCLUDES and setting the cache variable VAR
2313 # accordingly.
2314 ac_fn_cxx_check_header_mongrel ()
2315 {
2316   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2317   if eval \${$3+:} false; then :
2318   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2319 $as_echo_n "checking for $2... " >&6; }
2320 if eval \${$3+:} false; then :
2321   $as_echo_n "(cached) " >&6
2322 fi
2323 eval ac_res=\$$3
2324                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2325 $as_echo "$ac_res" >&6; }
2326 else
2327   # Is the header compilable?
2328 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2329 $as_echo_n "checking $2 usability... " >&6; }
2330 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2331 /* end confdefs.h.  */
2332 $4
2333 #include <$2>
2334 _ACEOF
2335 if ac_fn_cxx_try_compile "$LINENO"; then :
2336   ac_header_compiler=yes
2337 else
2338   ac_header_compiler=no
2339 fi
2340 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2341 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2342 $as_echo "$ac_header_compiler" >&6; }
2343 
2344 # Is the header present?
2345 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2346 $as_echo_n "checking $2 presence... " >&6; }
2347 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2348 /* end confdefs.h.  */
2349 #include <$2>
2350 _ACEOF
2351 if ac_fn_cxx_try_cpp "$LINENO"; then :
2352   ac_header_preproc=yes
2353 else
2354   ac_header_preproc=no
2355 fi
2356 rm -f conftest.err conftest.i conftest.$ac_ext
2357 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2358 $as_echo "$ac_header_preproc" >&6; }
2359 
2360 # So?  What about this header?
2361 case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2362   yes:no: )
2363     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2364 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2365     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2366 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2367     ;;
2368   no:yes:* )
2369     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2370 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2371     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
2372 $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
2373     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2374 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2375     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
2376 $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
2377     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2378 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2379 ( $as_echo "## ----------------------------------------- ##
2380 ## Report this to build-dev@openjdk.java.net ##
2381 ## ----------------------------------------- ##"
2382      ) | sed "s/^/$as_me: WARNING:     /" >&2
2383     ;;
2384 esac
2385   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2386 $as_echo_n "checking for $2... " >&6; }
2387 if eval \${$3+:} false; then :
2388   $as_echo_n "(cached) " >&6
2389 else
2390   eval "$3=\$ac_header_compiler"
2391 fi
2392 eval ac_res=\$$3
2393                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2394 $as_echo "$ac_res" >&6; }
2395 fi
2396   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2397 
2398 } # ac_fn_cxx_check_header_mongrel
2399 
2400 # ac_fn_cxx_try_run LINENO
2401 # ------------------------
2402 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2403 # that executables *can* be run.
2404 ac_fn_cxx_try_run ()
2405 {
2406   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2407   if { { ac_try="$ac_link"
2408 case "(($ac_try" in
2409   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2410   *) ac_try_echo=$ac_try;;
2411 esac
2412 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2413 $as_echo "$ac_try_echo"; } >&5
2414   (eval "$ac_link") 2>&5
2415   ac_status=$?
2416   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2417   test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2418   { { case "(($ac_try" in
2419   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2420   *) ac_try_echo=$ac_try;;
2421 esac
2422 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2423 $as_echo "$ac_try_echo"; } >&5
2424   (eval "$ac_try") 2>&5
2425   ac_status=$?
2426   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2427   test $ac_status = 0; }; }; then :
2428   ac_retval=0
2429 else
2430   $as_echo "$as_me: program exited with status $ac_status" >&5
2431        $as_echo "$as_me: failed program was:" >&5
2432 sed 's/^/| /' conftest.$ac_ext >&5
2433 
2434        ac_retval=$ac_status
2435 fi
2436   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2437   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2438   as_fn_set_status $ac_retval
2439 
2440 } # ac_fn_cxx_try_run
2441 
2442 # ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
2443 # ---------------------------------------------------------
2444 # Tests whether HEADER exists and can be compiled using the include files in
2445 # INCLUDES, setting the cache variable VAR accordingly.
2446 ac_fn_cxx_check_header_compile ()
2447 {
2448   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2449   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2450 $as_echo_n "checking for $2... " >&6; }
2451 if eval \${$3+:} false; then :
2452   $as_echo_n "(cached) " >&6
2453 else
2454   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2455 /* end confdefs.h.  */
2456 $4
2457 #include <$2>
2458 _ACEOF
2459 if ac_fn_cxx_try_compile "$LINENO"; then :
2460   eval "$3=yes"
2461 else
2462   eval "$3=no"
2463 fi
2464 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2465 fi
2466 eval ac_res=\$$3
2467                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2468 $as_echo "$ac_res" >&6; }
2469   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2470 
2471 } # ac_fn_cxx_check_header_compile
2472 
2473 # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
2474 # ----------------------------------------------
2475 # Tries to find the compile-time value of EXPR in a program that includes
2476 # INCLUDES, setting VAR accordingly. Returns whether the value could be
2477 # computed
2478 ac_fn_cxx_compute_int ()
2479 {
2480   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2481   if test "$cross_compiling" = yes; then
2482     # Depending upon the size, compute the lo and hi bounds.
2483 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2484 /* end confdefs.h.  */
2485 $4
2486 int
2487 main ()
2488 {
2489 static int test_array [1 - 2 * !(($2) >= 0)];
2490 test_array [0] = 0;
2491 return test_array [0];
2492 
2493   ;
2494   return 0;
2495 }
2496 _ACEOF
2497 if ac_fn_cxx_try_compile "$LINENO"; then :
2498   ac_lo=0 ac_mid=0
2499   while :; do
2500     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2501 /* end confdefs.h.  */
2502 $4
2503 int
2504 main ()
2505 {
2506 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2507 test_array [0] = 0;
2508 return test_array [0];
2509 
2510   ;
2511   return 0;
2512 }
2513 _ACEOF
2514 if ac_fn_cxx_try_compile "$LINENO"; then :
2515   ac_hi=$ac_mid; break
2516 else
2517   as_fn_arith $ac_mid + 1 && ac_lo=$as_val
2518                         if test $ac_lo -le $ac_mid; then
2519                           ac_lo= ac_hi=
2520                           break
2521                         fi
2522                         as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
2523 fi
2524 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2525   done
2526 else
2527   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2528 /* end confdefs.h.  */
2529 $4
2530 int
2531 main ()
2532 {
2533 static int test_array [1 - 2 * !(($2) < 0)];
2534 test_array [0] = 0;
2535 return test_array [0];
2536 
2537   ;
2538   return 0;
2539 }
2540 _ACEOF
2541 if ac_fn_cxx_try_compile "$LINENO"; then :
2542   ac_hi=-1 ac_mid=-1
2543   while :; do
2544     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2545 /* end confdefs.h.  */
2546 $4
2547 int
2548 main ()
2549 {
2550 static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2551 test_array [0] = 0;
2552 return test_array [0];
2553 
2554   ;
2555   return 0;
2556 }
2557 _ACEOF
2558 if ac_fn_cxx_try_compile "$LINENO"; then :
2559   ac_lo=$ac_mid; break
2560 else
2561   as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2562                         if test $ac_mid -le $ac_hi; then
2563                           ac_lo= ac_hi=
2564                           break
2565                         fi
2566                         as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2567 fi
2568 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2569   done
2570 else
2571   ac_lo= ac_hi=
2572 fi
2573 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2574 fi
2575 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2576 # Binary search between lo and hi bounds.
2577 while test "x$ac_lo" != "x$ac_hi"; do
2578   as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2579   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2580 /* end confdefs.h.  */
2581 $4
2582 int
2583 main ()
2584 {
2585 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2586 test_array [0] = 0;
2587 return test_array [0];
2588 
2589   ;
2590   return 0;
2591 }
2592 _ACEOF
2593 if ac_fn_cxx_try_compile "$LINENO"; then :
2594   ac_hi=$ac_mid
2595 else
2596   as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2597 fi
2598 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2599 done
2600 case $ac_lo in #((
2601 ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2602 '') ac_retval=1 ;;
2603 esac
2604   else
2605     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2606 /* end confdefs.h.  */
2607 $4
2608 static long int longval () { return $2; }
2609 static unsigned long int ulongval () { return $2; }
2610 #include <stdio.h>
2611 #include <stdlib.h>
2612 int
2613 main ()
2614 {
2615 
2616   FILE *f = fopen ("conftest.val", "w");
2617   if (! f)
2618     return 1;
2619   if (($2) < 0)
2620     {
2621       long int i = longval ();
2622       if (i != ($2))
2623         return 1;
2624       fprintf (f, "%ld", i);
2625     }
2626   else
2627     {
2628       unsigned long int i = ulongval ();
2629       if (i != ($2))
2630         return 1;
2631       fprintf (f, "%lu", i);
2632     }
2633   /* Do not output a trailing newline, as this causes \r\n confusion
2634      on some platforms.  */
2635   return ferror (f) || fclose (f) != 0;
2636 
2637   ;
2638   return 0;
2639 }
2640 _ACEOF
2641 if ac_fn_cxx_try_run "$LINENO"; then :
2642   echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2643 else
2644   ac_retval=1
2645 fi
2646 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2647   conftest.$ac_objext conftest.beam conftest.$ac_ext
2648 rm -f conftest.val
2649 
2650   fi
2651   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2652   as_fn_set_status $ac_retval
2653 
2654 } # ac_fn_cxx_compute_int
2655 
2656 # ac_fn_cxx_try_link LINENO
2657 # -------------------------
2658 # Try to link conftest.$ac_ext, and return whether this succeeded.
2659 ac_fn_cxx_try_link ()
2660 {
2661   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2662   rm -f conftest.$ac_objext conftest$ac_exeext
2663   if { { ac_try="$ac_link"
2664 case "(($ac_try" in
2665   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2666   *) ac_try_echo=$ac_try;;
2667 esac
2668 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2669 $as_echo "$ac_try_echo"; } >&5
2670   (eval "$ac_link") 2>conftest.err
2671   ac_status=$?
2672   if test -s conftest.err; then
2673     grep -v '^ *+' conftest.err >conftest.er1
2674     cat conftest.er1 >&5
2675     mv -f conftest.er1 conftest.err
2676   fi
2677   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2678   test $ac_status = 0; } && {
2679          test -z "$ac_cxx_werror_flag" ||
2680          test ! -s conftest.err
2681        } && test -s conftest$ac_exeext && {
2682          test "$cross_compiling" = yes ||
2683          test -x conftest$ac_exeext
2684        }; then :
2685   ac_retval=0
2686 else
2687   $as_echo "$as_me: failed program was:" >&5
2688 sed 's/^/| /' conftest.$ac_ext >&5
2689 
2690         ac_retval=1
2691 fi
2692   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2693   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2694   # interfere with the next link command; also delete a directory that is
2695   # left behind by Apple's compiler.  We do this before executing the actions.
2696   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2697   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2698   as_fn_set_status $ac_retval
2699 
2700 } # ac_fn_cxx_try_link
2701 
2702 # ac_fn_cxx_check_func LINENO FUNC VAR
2703 # ------------------------------------
2704 # Tests whether FUNC exists, setting the cache variable VAR accordingly
2705 ac_fn_cxx_check_func ()
2706 {
2707   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2708   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2709 $as_echo_n "checking for $2... " >&6; }
2710 if eval \${$3+:} false; then :
2711   $as_echo_n "(cached) " >&6
2712 else
2713   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2714 /* end confdefs.h.  */
2715 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
2716    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
2717 #define $2 innocuous_$2
2718 
2719 /* System header to define __stub macros and hopefully few prototypes,
2720     which can conflict with char $2 (); below.
2721     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2722     <limits.h> exists even on freestanding compilers.  */
2723 
2724 #ifdef __STDC__
2725 # include <limits.h>
2726 #else
2727 # include <assert.h>
2728 #endif
2729 
2730 #undef $2
2731 
2732 /* Override any GCC internal prototype to avoid an error.
2733    Use char because int might match the return type of a GCC
2734    builtin and then its argument prototype would still apply.  */
2735 #ifdef __cplusplus
2736 extern "C"
2737 #endif
2738 char $2 ();
2739 /* The GNU C library defines this for functions which it implements
2740     to always fail with ENOSYS.  Some functions are actually named
2741     something starting with __ and the normal name is an alias.  */
2742 #if defined __stub_$2 || defined __stub___$2
2743 choke me
2744 #endif
2745 
2746 int
2747 main ()
2748 {
2749 return $2 ();
2750   ;
2751   return 0;
2752 }
2753 _ACEOF
2754 if ac_fn_cxx_try_link "$LINENO"; then :
2755   eval "$3=yes"
2756 else
2757   eval "$3=no"
2758 fi
2759 rm -f core conftest.err conftest.$ac_objext \
2760     conftest$ac_exeext conftest.$ac_ext
2761 fi
2762 eval ac_res=\$$3
2763                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2764 $as_echo "$ac_res" >&6; }
2765   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2766 
2767 } # ac_fn_cxx_check_func
2768 
2769 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
2770 # -------------------------------------------------------
2771 # Tests whether HEADER exists and can be compiled using the include files in
2772 # INCLUDES, setting the cache variable VAR accordingly.
2773 ac_fn_c_check_header_compile ()
2774 {
2775   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2776   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2777 $as_echo_n "checking for $2... " >&6; }
2778 if eval \${$3+:} false; then :
2779   $as_echo_n "(cached) " >&6
2780 else
2781   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2782 /* end confdefs.h.  */
2783 $4
2784 #include <$2>
2785 _ACEOF
2786 if ac_fn_c_try_compile "$LINENO"; then :
2787   eval "$3=yes"
2788 else
2789   eval "$3=no"
2790 fi
2791 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2792 fi
2793 eval ac_res=\$$3
2794                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2795 $as_echo "$ac_res" >&6; }
2796   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2797 
2798 } # ac_fn_c_check_header_compile
2799 cat >config.log <<_ACEOF
2800 This file contains any messages produced by compilers while
2801 running configure, to aid debugging if configure makes a mistake.
2802 
2803 It was created by OpenJDK $as_me jdk8, which was
2804 generated by GNU Autoconf 2.69.  Invocation command line was
2805 
2806   $ $0 $@
2807 
2808 _ACEOF
2809 exec 5>>config.log
2810 {
2811 cat <<_ASUNAME
2812 ## --------- ##
2813 ## Platform. ##
2814 ## --------- ##
2815 
2816 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
2817 uname -m = `(uname -m) 2>/dev/null || echo unknown`
2818 uname -r = `(uname -r) 2>/dev/null || echo unknown`
2819 uname -s = `(uname -s) 2>/dev/null || echo unknown`
2820 uname -v = `(uname -v) 2>/dev/null || echo unknown`
2821 
2822 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
2823 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
2824 
2825 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
2826 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
2827 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
2828 /usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
2829 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
2830 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
2831 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
2832 
2833 _ASUNAME
2834 
2835 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2836 for as_dir in $PATH
2837 do
2838   IFS=$as_save_IFS
2839   test -z "$as_dir" && as_dir=.
2840     $as_echo "PATH: $as_dir"
2841   done
2842 IFS=$as_save_IFS
2843 
2844 } >&5
2845 
2846 cat >&5 <<_ACEOF
2847 
2848 
2849 ## ----------- ##
2850 ## Core tests. ##
2851 ## ----------- ##
2852 
2853 _ACEOF
2854 
2855 
2856 # Keep a trace of the command line.
2857 # Strip out --no-create and --no-recursion so they do not pile up.
2858 # Strip out --silent because we don't want to record it for future runs.
2859 # Also quote any args containing shell meta-characters.
2860 # Make two passes to allow for proper duplicate-argument suppression.
2861 ac_configure_args=
2862 ac_configure_args0=
2863 ac_configure_args1=
2864 ac_must_keep_next=false
2865 for ac_pass in 1 2
2866 do
2867   for ac_arg
2868   do
2869     case $ac_arg in
2870     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
2871     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
2872     | -silent | --silent | --silen | --sile | --sil)
2873       continue ;;
2874     *\'*)
2875       ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
2876     esac
2877     case $ac_pass in
2878     1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2879     2)
2880       as_fn_append ac_configure_args1 " '$ac_arg'"
2881       if test $ac_must_keep_next = true; then
2882         ac_must_keep_next=false # Got value, back to normal.
2883       else
2884         case $ac_arg in
2885           *=* | --config-cache | -C | -disable-* | --disable-* \
2886           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
2887           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
2888           | -with-* | --with-* | -without-* | --without-* | --x)
2889             case "$ac_configure_args0 " in
2890               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
2891             esac
2892             ;;
2893           -* ) ac_must_keep_next=true ;;
2894         esac
2895       fi
2896       as_fn_append ac_configure_args " '$ac_arg'"
2897       ;;
2898     esac
2899   done
2900 done
2901 { ac_configure_args0=; unset ac_configure_args0;}
2902 { ac_configure_args1=; unset ac_configure_args1;}
2903 
2904 # When interrupted or exit'd, cleanup temporary files, and complete
2905 # config.log.  We remove comments because anyway the quotes in there
2906 # would cause problems or look ugly.
2907 # WARNING: Use '\'' to represent an apostrophe within the trap.
2908 # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
2909 trap 'exit_status=$?
2910   # Save into config.log some information that might help in debugging.
2911   {
2912     echo
2913 
2914     $as_echo "## ---------------- ##
2915 ## Cache variables. ##
2916 ## ---------------- ##"
2917     echo
2918     # The following way of writing the cache mishandles newlines in values,
2919 (
2920   for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
2921     eval ac_val=\$$ac_var
2922     case $ac_val in #(
2923     *${as_nl}*)
2924       case $ac_var in #(
2925       *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
2926 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
2927       esac
2928       case $ac_var in #(
2929       _ | IFS | as_nl) ;; #(
2930       BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
2931       *) { eval $ac_var=; unset $ac_var;} ;;
2932       esac ;;
2933     esac
2934   done
2935   (set) 2>&1 |
2936     case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
2937     *${as_nl}ac_space=\ *)
2938       sed -n \
2939         "s/'\''/'\''\\\\'\'''\''/g;
2940           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
2941       ;; #(
2942     *)
2943       sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
2944       ;;
2945     esac |
2946     sort
2947 )
2948     echo
2949 
2950     $as_echo "## ----------------- ##
2951 ## Output variables. ##
2952 ## ----------------- ##"
2953     echo
2954     for ac_var in $ac_subst_vars
2955     do
2956       eval ac_val=\$$ac_var
2957       case $ac_val in
2958       *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
2959       esac
2960       $as_echo "$ac_var='\''$ac_val'\''"
2961     done | sort
2962     echo
2963 
2964     if test -n "$ac_subst_files"; then
2965       $as_echo "## ------------------- ##
2966 ## File substitutions. ##
2967 ## ------------------- ##"
2968       echo
2969       for ac_var in $ac_subst_files
2970       do
2971         eval ac_val=\$$ac_var
2972         case $ac_val in
2973         *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
2974         esac
2975         $as_echo "$ac_var='\''$ac_val'\''"
2976       done | sort
2977       echo
2978     fi
2979 
2980     if test -s confdefs.h; then
2981       $as_echo "## ----------- ##
2982 ## confdefs.h. ##
2983 ## ----------- ##"
2984       echo
2985       cat confdefs.h
2986       echo
2987     fi
2988     test "$ac_signal" != 0 &&
2989       $as_echo "$as_me: caught signal $ac_signal"
2990     $as_echo "$as_me: exit $exit_status"
2991   } >&5
2992   rm -f core *.core core.conftest.* &&
2993     rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
2994     exit $exit_status
2995 ' 0
2996 for ac_signal in 1 2 13 15; do
2997   trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
2998 done
2999 ac_signal=0
3000 
3001 # confdefs.h avoids OS command line length limits that DEFS can exceed.
3002 rm -f -r conftest* confdefs.h
3003 
3004 $as_echo "/* confdefs.h */" > confdefs.h
3005 
3006 # Predefined preprocessor variables.
3007 
3008 cat >>confdefs.h <<_ACEOF
3009 #define PACKAGE_NAME "$PACKAGE_NAME"
3010 _ACEOF
3011 
3012 cat >>confdefs.h <<_ACEOF
3013 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
3014 _ACEOF
3015 
3016 cat >>confdefs.h <<_ACEOF
3017 #define PACKAGE_VERSION "$PACKAGE_VERSION"
3018 _ACEOF
3019 
3020 cat >>confdefs.h <<_ACEOF
3021 #define PACKAGE_STRING "$PACKAGE_STRING"
3022 _ACEOF
3023 
3024 cat >>confdefs.h <<_ACEOF
3025 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
3026 _ACEOF
3027 
3028 cat >>confdefs.h <<_ACEOF
3029 #define PACKAGE_URL "$PACKAGE_URL"
3030 _ACEOF
3031 
3032 
3033 # Let the site file select an alternate cache file if it wants to.
3034 # Prefer an explicitly selected file to automatically selected ones.
3035 ac_site_file1=NONE
3036 ac_site_file2=NONE
3037 if test -n "$CONFIG_SITE"; then
3038   # We do not want a PATH search for config.site.
3039   case $CONFIG_SITE in #((
3040     -*)  ac_site_file1=./$CONFIG_SITE;;
3041     */*) ac_site_file1=$CONFIG_SITE;;
3042     *)   ac_site_file1=./$CONFIG_SITE;;
3043   esac
3044 elif test "x$prefix" != xNONE; then
3045   ac_site_file1=$prefix/share/config.site
3046   ac_site_file2=$prefix/etc/config.site
3047 else
3048   ac_site_file1=$ac_default_prefix/share/config.site
3049   ac_site_file2=$ac_default_prefix/etc/config.site
3050 fi
3051 for ac_site_file in "$ac_site_file1" "$ac_site_file2"
3052 do
3053   test "x$ac_site_file" = xNONE && continue
3054   if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
3055     { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
3056 $as_echo "$as_me: loading site script $ac_site_file" >&6;}
3057     sed 's/^/| /' "$ac_site_file" >&5
3058     . "$ac_site_file" \
3059       || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3060 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3061 as_fn_error $? "failed to load site script $ac_site_file
3062 See \`config.log' for more details" "$LINENO" 5; }
3063   fi
3064 done
3065 
3066 if test -r "$cache_file"; then
3067   # Some versions of bash will fail to source /dev/null (special files
3068   # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
3069   if test /dev/null != "$cache_file" && test -f "$cache_file"; then
3070     { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
3071 $as_echo "$as_me: loading cache $cache_file" >&6;}
3072     case $cache_file in
3073       [\\/]* | ?:[\\/]* ) . "$cache_file";;
3074       *)                      . "./$cache_file";;
3075     esac
3076   fi
3077 else
3078   { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
3079 $as_echo "$as_me: creating cache $cache_file" >&6;}
3080   >$cache_file
3081 fi
3082 
3083 # Check that the precious variables saved in the cache have kept the same
3084 # value.
3085 ac_cache_corrupted=false
3086 for ac_var in $ac_precious_vars; do
3087   eval ac_old_set=\$ac_cv_env_${ac_var}_set
3088   eval ac_new_set=\$ac_env_${ac_var}_set
3089   eval ac_old_val=\$ac_cv_env_${ac_var}_value
3090   eval ac_new_val=\$ac_env_${ac_var}_value
3091   case $ac_old_set,$ac_new_set in
3092     set,)
3093       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
3094 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
3095       ac_cache_corrupted=: ;;
3096     ,set)
3097       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
3098 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
3099       ac_cache_corrupted=: ;;
3100     ,);;
3101     *)
3102       if test "x$ac_old_val" != "x$ac_new_val"; then
3103         # differences in whitespace do not lead to failure.
3104         ac_old_val_w=`echo x $ac_old_val`
3105         ac_new_val_w=`echo x $ac_new_val`
3106         if test "$ac_old_val_w" != "$ac_new_val_w"; then
3107           { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
3108 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
3109           ac_cache_corrupted=:
3110         else
3111           { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
3112 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
3113           eval $ac_var=\$ac_old_val
3114         fi
3115         { $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
3116 $as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
3117         { $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
3118 $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
3119       fi;;
3120   esac
3121   # Pass precious variables to config.status.
3122   if test "$ac_new_set" = set; then
3123     case $ac_new_val in
3124     *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
3125     *) ac_arg=$ac_var=$ac_new_val ;;
3126     esac
3127     case " $ac_configure_args " in
3128       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
3129       *) as_fn_append ac_configure_args " '$ac_arg'" ;;
3130     esac
3131   fi
3132 done
3133 if $ac_cache_corrupted; then
3134   { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3135 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3136   { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
3137 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
3138   as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
3139 fi
3140 ## -------------------- ##
3141 ## Main body of script. ##
3142 ## -------------------- ##
3143 
3144 ac_ext=c
3145 ac_cpp='$CPP $CPPFLAGS'
3146 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3147 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3148 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3149 
3150 
3151 
3152 ac_aux_dir=
3153 for ac_dir in build-aux "$srcdir"/build-aux; do
3154   if test -f "$ac_dir/install-sh"; then
3155     ac_aux_dir=$ac_dir
3156     ac_install_sh="$ac_aux_dir/install-sh -c"
3157     break
3158   elif test -f "$ac_dir/install.sh"; then
3159     ac_aux_dir=$ac_dir
3160     ac_install_sh="$ac_aux_dir/install.sh -c"
3161     break
3162   elif test -f "$ac_dir/shtool"; then
3163     ac_aux_dir=$ac_dir
3164     ac_install_sh="$ac_aux_dir/shtool install -c"
3165     break
3166   fi
3167 done
3168 if test -z "$ac_aux_dir"; then
3169   as_fn_error $? "cannot find install-sh, install.sh, or shtool in build-aux \"$srcdir\"/build-aux" "$LINENO" 5
3170 fi
3171 
3172 # These three variables are undocumented and unsupported,
3173 # and are intended to be withdrawn in a future Autoconf release.
3174 # They can cause serious problems if a builder's source tree is in a directory
3175 # whose full name contains unusual characters.
3176 ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
3177 ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
3178 ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
3179 
3180 
3181 # pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
3182 
3183 #
3184 # Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3185 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3186 #
3187 # This code is free software; you can redistribute it and/or modify it
3188 # under the terms of the GNU General Public License version 2 only, as
3189 # published by the Free Software Foundation.  Oracle designates this
3190 # particular file as subject to the "Classpath" exception as provided
3191 # by Oracle in the LICENSE file that accompanied this code.
3192 #
3193 # This code is distributed in the hope that it will be useful, but WITHOUT
3194 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3195 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3196 # version 2 for more details (a copy is included in the LICENSE file that
3197 # accompanied this code).
3198 #
3199 # You should have received a copy of the GNU General Public License version
3200 # 2 along with this work; if not, write to the Free Software Foundation,
3201 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3202 #
3203 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3204 # or visit www.oracle.com if you need additional information or have any
3205 # questions.
3206 #
3207 
3208 #
3209 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
3210 #
3211 # This program is free software; you can redistribute it and/or modify
3212 # it under the terms of the GNU General Public License as published by
3213 # the Free Software Foundation; either version 2 of the License, or
3214 # (at your option) any later version.
3215 #
3216 # This program is distributed in the hope that it will be useful, but
3217 # WITHOUT ANY WARRANTY; without even the implied warranty of
3218 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3219 # General Public License for more details.
3220 #
3221 # You should have received a copy of the GNU General Public License
3222 # along with this program; if not, write to the Free Software
3223 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3224 #
3225 # As a special exception to the GNU General Public License, if you
3226 # distribute this file as part of a program that contains a
3227 # configuration script generated by Autoconf, you may include it under
3228 # the same distribution terms that you use for the rest of that program.
3229 
3230 # PKG_PROG_PKG_CONFIG([MIN-VERSION])
3231 # ----------------------------------
3232 # PKG_PROG_PKG_CONFIG
3233 
3234 # PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
3235 #
3236 # Check to see whether a particular set of modules exists.  Similar
3237 # to PKG_CHECK_MODULES(), but does not set variables or print errors.
3238 #
3239 #
3240 # Similar to PKG_CHECK_MODULES, make sure that the first instance of
3241 # this or PKG_CHECK_MODULES is called, or make sure to call
3242 # PKG_CHECK_EXISTS manually
3243 # --------------------------------------------------------------
3244 
3245 
3246 
3247 # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
3248 # ---------------------------------------------
3249 # _PKG_CONFIG
3250 
3251 # _PKG_SHORT_ERRORS_SUPPORTED
3252 # -----------------------------
3253 # _PKG_SHORT_ERRORS_SUPPORTED
3254 
3255 
3256 # PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
3257 # [ACTION-IF-NOT-FOUND])
3258 #
3259 #
3260 # Note that if there is a possibility the first call to
3261 # PKG_CHECK_MODULES might not happen, you should be sure to include an
3262 # explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
3263 #
3264 #
3265 # --------------------------------------------------------------
3266 # PKG_CHECK_MODULES
3267 
3268 
3269 # Include these first...
3270 #
3271 # Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
3272 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3273 #
3274 # This code is free software; you can redistribute it and/or modify it
3275 # under the terms of the GNU General Public License version 2 only, as
3276 # published by the Free Software Foundation.  Oracle designates this
3277 # particular file as subject to the "Classpath" exception as provided
3278 # by Oracle in the LICENSE file that accompanied this code.
3279 #
3280 # This code is distributed in the hope that it will be useful, but WITHOUT
3281 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3282 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3283 # version 2 for more details (a copy is included in the LICENSE file that
3284 # accompanied this code).
3285 #
3286 # You should have received a copy of the GNU General Public License version
3287 # 2 along with this work; if not, write to the Free Software Foundation,
3288 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3289 #
3290 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3291 # or visit www.oracle.com if you need additional information or have any
3292 # questions.
3293 #
3294 
3295 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3296 # If so, then append $1 to $2 \
3297 # Also set JVM_ARG_OK to true/false depending on outcome.
3298 
3299 
3300 # Appends a string to a path variable, only adding the : when needed.
3301 
3302 
3303 # This will make sure the given variable points to a full and proper
3304 # path. This means:
3305 # 1) There will be no spaces in the path. On posix platforms,
3306 #    spaces in the path will result in an error. On Windows,
3307 #    the path will be rewritten using short-style to be space-free.
3308 # 2) The path will be absolute, and it will be in unix-style (on
3309 #     cygwin).
3310 # $1: The name of the variable to fix
3311 
3312 
3313 # This will make sure the given variable points to a executable
3314 # with a full and proper path. This means:
3315 # 1) There will be no spaces in the path. On posix platforms,
3316 #    spaces in the path will result in an error. On Windows,
3317 #    the path will be rewritten using short-style to be space-free.
3318 # 2) The path will be absolute, and it will be in unix-style (on
3319 #     cygwin).
3320 # Any arguments given to the executable is preserved.
3321 # If the input variable does not have a directory specification, then
3322 # it need to be in the PATH.
3323 # $1: The name of the variable to fix
3324 
3325 
3326 
3327 
3328 # Register a --with argument but mark it as deprecated
3329 # $1: The name of the with argument to deprecate, not including --with-
3330 
3331 
3332 # Register a --enable argument but mark it as deprecated
3333 # $1: The name of the with argument to deprecate, not including --enable-
3334 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3335 
3336 
3337 
3338 
3339 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3340 # $1: variable to check
3341 
3342 
3343 # Check that there are no unprocessed overridden variables left.
3344 # If so, they are an incorrect argument and we will exit with an error.
3345 
3346 
3347 # Setup a tool for the given variable. If correctly specified by the user,
3348 # use that value, otherwise search for the tool using the supplied code snippet.
3349 # $1: variable to set
3350 # $2: code snippet to call to look for the tool
3351 
3352 
3353 # Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
3354 # $1: variable to set
3355 # $2: executable name (or list of names) to look for
3356 
3357 
3358 # Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
3359 # $1: variable to set
3360 # $2: executable name (or list of names) to look for
3361 
3362 
3363 # Like BASIC_PATH_PROGS but fails if no tool was found.
3364 # $1: variable to set
3365 # $2: executable name (or list of names) to look for
3366 
3367 
3368 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3369 # $1: variable to set
3370 # $2: autoconf macro to call to look for the special tool
3371 
3372 
3373 # Setup the most fundamental tools that relies on not much else to set up,
3374 # but is used by much of the early bootstrap code.
3375 
3376 
3377 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3378 
3379 
3380 
3381 
3382 
3383 
3384 
3385 #%%% Simple tools %%%
3386 
3387 # Check if we have found a usable version of make
3388 # $1: the path to a potential make binary (or empty)
3389 # $2: the description on how we found this
3390 
3391 
3392 # Goes looking for a usable version of GNU make.
3393 
3394 
3395 
3396 
3397 
3398 
3399 # Check if build directory is on local disk. If not possible to determine,
3400 # we prefer to claim it's local.
3401 # Argument 1: directory to test
3402 # Argument 2: what to do if it is on local disk
3403 # Argument 3: what to do otherwise (remote disk or failure)
3404 
3405 
3406 # Check that source files have basic read permissions set. This might
3407 # not be the case in cygwin in certain conditions.
3408 
3409 
3410 
3411 
3412 #
3413 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3414 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3415 #
3416 # This code is free software; you can redistribute it and/or modify it
3417 # under the terms of the GNU General Public License version 2 only, as
3418 # published by the Free Software Foundation.  Oracle designates this
3419 # particular file as subject to the "Classpath" exception as provided
3420 # by Oracle in the LICENSE file that accompanied this code.
3421 #
3422 # This code is distributed in the hope that it will be useful, but WITHOUT
3423 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3424 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3425 # version 2 for more details (a copy is included in the LICENSE file that
3426 # accompanied this code).
3427 #
3428 # You should have received a copy of the GNU General Public License version
3429 # 2 along with this work; if not, write to the Free Software Foundation,
3430 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3431 #
3432 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3433 # or visit www.oracle.com if you need additional information or have any
3434 # questions.
3435 #
3436 
3437 
3438 
3439 
3440 
3441 # Helper function which possibly converts a path using DOS-style short mode.
3442 # If so, the updated path is stored in $new_path.
3443 # $1: The path to check
3444 
3445 
3446 # Helper function which possibly converts a path using DOS-style short mode.
3447 # If so, the updated path is stored in $new_path.
3448 # $1: The path to check
3449 
3450 
3451 # FIXME: The BASIC_FIXUP_*_CYGWIN/MSYS is most likely too convoluted
3452 # and could probably be heavily simplified. However, all changes in this
3453 # area tend to need lot of testing in different scenarios, and in lack of
3454 # proper unit testing, cleaning this up has not been deemed worth the effort
3455 # at the moment.
3456 
3457 
3458 
3459 
3460 
3461 
3462 
3463 
3464 
3465 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3466 
3467 
3468 
3469 
3470 #
3471 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3472 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3473 #
3474 # This code is free software; you can redistribute it and/or modify it
3475 # under the terms of the GNU General Public License version 2 only, as
3476 # published by the Free Software Foundation.  Oracle designates this
3477 # particular file as subject to the "Classpath" exception as provided
3478 # by Oracle in the LICENSE file that accompanied this code.
3479 #
3480 # This code is distributed in the hope that it will be useful, but WITHOUT
3481 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3482 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3483 # version 2 for more details (a copy is included in the LICENSE file that
3484 # accompanied this code).
3485 #
3486 # You should have received a copy of the GNU General Public License version
3487 # 2 along with this work; if not, write to the Free Software Foundation,
3488 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3489 #
3490 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3491 # or visit www.oracle.com if you need additional information or have any
3492 # questions.
3493 #
3494 
3495 
3496 
3497 
3498 
3499 
3500 
3501 
3502 
3503 
3504 
3505 # ... then the rest
3506 #
3507 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3508 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3509 #
3510 # This code is free software; you can redistribute it and/or modify it
3511 # under the terms of the GNU General Public License version 2 only, as
3512 # published by the Free Software Foundation.  Oracle designates this
3513 # particular file as subject to the "Classpath" exception as provided
3514 # by Oracle in the LICENSE file that accompanied this code.
3515 #
3516 # This code is distributed in the hope that it will be useful, but WITHOUT
3517 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3518 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3519 # version 2 for more details (a copy is included in the LICENSE file that
3520 # accompanied this code).
3521 #
3522 # You should have received a copy of the GNU General Public License version
3523 # 2 along with this work; if not, write to the Free Software Foundation,
3524 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3525 #
3526 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3527 # or visit www.oracle.com if you need additional information or have any
3528 # questions.
3529 #
3530 
3531 ########################################################################
3532 # This file handles detection of the Boot JDK. The Boot JDK detection
3533 # process has been developed as a response to solve a complex real-world
3534 # problem. Initially, it was simple, but it has grown as platform after
3535 # platform, idiosyncracy after idiosyncracy has been supported.
3536 #
3537 # The basic idea is this:
3538 # 1) You need an acceptable *) JDK to use as a Boot JDK
3539 # 2) There are several ways to locate a JDK, that are mostly platform
3540 #    dependent **)
3541 # 3) You can have multiple JDKs installed
3542 # 4) If possible, configure should try to dig out an acceptable JDK
3543 #    automatically, without having to resort to command-line options
3544 #
3545 # *)  acceptable means e.g. JDK7 for building JDK8, a complete JDK (with
3546 #     javac) and not a JRE, etc.
3547 #
3548 # **) On Windows we typically use a well-known path.
3549 #     On MacOSX we typically use the tool java_home.
3550 #     On Linux we typically find javac in the $PATH, and then follow a
3551 #     chain of symlinks that often ends up in a real JDK.
3552 #
3553 # This leads to the code where we check in different ways to locate a
3554 # JDK, and if one is found, check if it is acceptable. If not, we print
3555 # our reasons for rejecting it (useful when debugging non-working
3556 # configure situations) and continue checking the next one.
3557 ########################################################################
3558 
3559 # Execute the check given as argument, and verify the result
3560 # If the Boot JDK was previously found, do nothing
3561 # $1 A command line (typically autoconf macro) to execute
3562 
3563 
3564 # Test: Is bootjdk explicitely set by command line arguments?
3565 
3566 
3567 # Test: Is bootjdk available from builddeps?
3568 
3569 
3570 # Test: Is $JAVA_HOME set?
3571 
3572 
3573 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
3574 
3575 
3576 # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
3577 # $1: Argument to the java_home binary (optional)
3578 
3579 
3580 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
3581 
3582 
3583 # Look for a jdk in the given path. If there are multiple, try to select the newest.
3584 # If found, set BOOT_JDK and BOOT_JDK_FOUND.
3585 # $1 = Path to directory containing jdk installations.
3586 # $2 = String to append to the found JDK directory to get the proper JDK home
3587 
3588 
3589 # Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
3590 # environmental variable as base for where to look.
3591 # $1 Name of an environmal variable, assumed to point to the Program Files directory.
3592 
3593 
3594 # Test: Is there a JDK installed in default, well-known locations?
3595 
3596 
3597 # Check that a command-line tool in the Boot JDK is correct
3598 # $1 = name of variable to assign
3599 # $2 = name of binary
3600 
3601 
3602 ###############################################################################
3603 #
3604 # We need a Boot JDK to bootstrap the build.
3605 #
3606 
3607 
3608 
3609 
3610 
3611 #
3612 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3613 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3614 #
3615 # This code is free software; you can redistribute it and/or modify it
3616 # under the terms of the GNU General Public License version 2 only, as
3617 # published by the Free Software Foundation.  Oracle designates this
3618 # particular file as subject to the "Classpath" exception as provided
3619 # by Oracle in the LICENSE file that accompanied this code.
3620 #
3621 # This code is distributed in the hope that it will be useful, but WITHOUT
3622 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3623 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3624 # version 2 for more details (a copy is included in the LICENSE file that
3625 # accompanied this code).
3626 #
3627 # You should have received a copy of the GNU General Public License version
3628 # 2 along with this work; if not, write to the Free Software Foundation,
3629 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3630 #
3631 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3632 # or visit www.oracle.com if you need additional information or have any
3633 # questions.
3634 #
3635 
3636 
3637 
3638 
3639 
3640 
3641 
3642 
3643 
3644 
3645 
3646 
3647 
3648 
3649 
3650 
3651 
3652 
3653 
3654 
3655 #
3656 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3657 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3658 #
3659 # This code is free software; you can redistribute it and/or modify it
3660 # under the terms of the GNU General Public License version 2 only, as
3661 # published by the Free Software Foundation.  Oracle designates this
3662 # particular file as subject to the "Classpath" exception as provided
3663 # by Oracle in the LICENSE file that accompanied this code.
3664 #
3665 # This code is distributed in the hope that it will be useful, but WITHOUT
3666 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3667 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3668 # version 2 for more details (a copy is included in the LICENSE file that
3669 # accompanied this code).
3670 #
3671 # You should have received a copy of the GNU General Public License version
3672 # 2 along with this work; if not, write to the Free Software Foundation,
3673 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3674 #
3675 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3676 # or visit www.oracle.com if you need additional information or have any
3677 # questions.
3678 #
3679 
3680 
3681 
3682 
3683 
3684 cygwin_help() {
3685   case $1 in
3686     unzip)
3687       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P unzip )"
3688       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3689       ;;
3690     zip)
3691       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P zip )"
3692       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3693       ;;
3694     make)
3695       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P make )"
3696       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3697       ;;
3698     freetype)
3699       if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
3700         HELP_MSG="To install freetype, run:
3701 wget \"http://gnuwin32.sourceforge.net/downlinks/freetype.php\" -O /tmp/freetype-setup.exe
3702 chmod +x /tmp/freetype-setup.exe
3703 /tmp/freetype-setup.exe
3704 Follow GUI prompts, and install to default directory \"C:\Program Files (x86)\GnuWin32\".
3705 After installation, locate lib/libfreetype.dll.a and make a copy with the name freetype.dll."
3706       else
3707         HELP_MSG="You need to build a 64-bit version of freetype.
3708 This is not readily available.
3709 You can find source code and build instructions on
3710 http://www.freetype.org/
3711 If you put the resulting build in \"C:\Program Files\GnuWin32\", it will be found automatically."
3712       fi
3713       ;;
3714   esac
3715 }
3716 
3717 msys_help() {
3718   PKGHANDLER_COMMAND=""
3719 }
3720 
3721 apt_help() {
3722   case $1 in
3723     devkit)
3724       PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;;
3725     openjdk)
3726       PKGHANDLER_COMMAND="sudo apt-get install openjdk-7-jdk" ;;
3727     alsa)
3728       PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;;
3729     cups)
3730       PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;;
3731     freetype)
3732       PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;;
3733     pulse)
3734       PKGHANDLER_COMMAND="sudo apt-get install libpulse-dev" ;;
3735     x11)
3736       PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
3737     ccache)
3738       PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
3739   esac
3740 }
3741 
3742 yum_help() {
3743   case $1 in
3744     devkit)
3745       PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;;
3746     openjdk)
3747       PKGHANDLER_COMMAND="sudo yum install java-1.7.0-openjdk" ;;
3748     alsa)
3749       PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;;
3750     cups)
3751       PKGHANDLER_COMMAND="sudo yum install cups-devel" ;;
3752     freetype)
3753       PKGHANDLER_COMMAND="sudo yum install freetype-devel" ;;
3754     pulse)
3755       PKGHANDLER_COMMAND="sudo yum install pulseaudio-libs-devel" ;;
3756     x11)
3757       PKGHANDLER_COMMAND="sudo yum install libXtst-devel libXt-devel libXrender-devel" ;;
3758     ccache)
3759       PKGHANDLER_COMMAND="sudo yum install ccache" ;;
3760   esac
3761 }
3762 
3763 port_help() {
3764   PKGHANDLER_COMMAND=""
3765 }
3766 
3767 pkgutil_help() {
3768   PKGHANDLER_COMMAND=""
3769 }
3770 
3771 pkgadd_help() {
3772   PKGHANDLER_COMMAND=""
3773 }
3774 
3775 
3776 
3777 #
3778 # Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
3779 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3780 #
3781 # This code is free software; you can redistribute it and/or modify it
3782 # under the terms of the GNU General Public License version 2 only, as
3783 # published by the Free Software Foundation.  Oracle designates this
3784 # particular file as subject to the "Classpath" exception as provided
3785 # by Oracle in the LICENSE file that accompanied this code.
3786 #
3787 # This code is distributed in the hope that it will be useful, but WITHOUT
3788 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3789 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3790 # version 2 for more details (a copy is included in the LICENSE file that
3791 # accompanied this code).
3792 #
3793 # You should have received a copy of the GNU General Public License version
3794 # 2 along with this work; if not, write to the Free Software Foundation,
3795 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3796 #
3797 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3798 # or visit www.oracle.com if you need additional information or have any
3799 # questions.
3800 #
3801 
3802 
3803 
3804 
3805 
3806 
3807 
3808 
3809 
3810 
3811 ###############################################################################
3812 #
3813 # Should we build only OpenJDK even if closed sources are present?
3814 #
3815 
3816 
3817 
3818 
3819 ###############################################################################
3820 #
3821 # Setup version numbers
3822 #
3823 
3824 
3825 
3826 
3827 
3828 
3829 # Support for customization of the build process. Some build files
3830 # will include counterparts from this location, if they exist. This allows
3831 # for a degree of customization of the build targets and the rules/recipes
3832 # to create them
3833 
3834 # Check whether --with-custom-make-dir was given.
3835 if test "${with_custom_make_dir+set}" = set; then :
3836   withval=$with_custom_make_dir; CUSTOM_MAKE_DIR=$with_custom_make_dir
3837 fi
3838 
3839 
3840 
3841 #
3842 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3843 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3844 #
3845 # This code is free software; you can redistribute it and/or modify it
3846 # under the terms of the GNU General Public License version 2 only, as
3847 # published by the Free Software Foundation.  Oracle designates this
3848 # particular file as subject to the "Classpath" exception as provided
3849 # by Oracle in the LICENSE file that accompanied this code.
3850 #
3851 # This code is distributed in the hope that it will be useful, but WITHOUT
3852 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3853 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3854 # version 2 for more details (a copy is included in the LICENSE file that
3855 # accompanied this code).
3856 #
3857 # You should have received a copy of the GNU General Public License version
3858 # 2 along with this work; if not, write to the Free Software Foundation,
3859 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3860 #
3861 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3862 # or visit www.oracle.com if you need additional information or have any
3863 # questions.
3864 #
3865 
3866 
3867 
3868 
3869 
3870 
3871 
3872 
3873 
3874 
3875 
3876 
3877 
3878 
3879 
3880 
3881 
3882 #
3883 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3884 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3885 #
3886 # This code is free software; you can redistribute it and/or modify it
3887 # under the terms of the GNU General Public License version 2 only, as
3888 # published by the Free Software Foundation.  Oracle designates this
3889 # particular file as subject to the "Classpath" exception as provided
3890 # by Oracle in the LICENSE file that accompanied this code.
3891 #
3892 # This code is distributed in the hope that it will be useful, but WITHOUT
3893 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3894 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3895 # version 2 for more details (a copy is included in the LICENSE file that
3896 # accompanied this code).
3897 #
3898 # You should have received a copy of the GNU General Public License version
3899 # 2 along with this work; if not, write to the Free Software Foundation,
3900 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3901 #
3902 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3903 # or visit www.oracle.com if you need additional information or have any
3904 # questions.
3905 #
3906 
3907 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
3908 # Converts autoconf style CPU name to OpenJDK style, into
3909 # VAR_CPU, VAR_CPU_ARCH, VAR_CPU_BITS and VAR_CPU_ENDIAN.
3910 
3911 
3912 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
3913 # Converts autoconf style OS name to OpenJDK style, into
3914 # VAR_OS and VAR_OS_API.
3915 
3916 
3917 # Expects $host_os $host_cpu $build_os and $build_cpu
3918 # and $with_target_bits to have been setup!
3919 #
3920 # Translate the standard triplet(quadruplet) definition
3921 # of the target/build system into OPENJDK_TARGET_OS, OPENJDK_TARGET_CPU,
3922 # OPENJDK_BUILD_OS, etc.
3923 
3924 
3925 # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
3926 # accordingly. Must be done after setting up build and target system, but before
3927 # doing anything else with these values.
3928 
3929 
3930 # Setup the legacy variables, for controlling the old makefiles.
3931 #
3932 
3933 
3934 
3935 
3936 #%%% Build and target systems %%%
3937 
3938 
3939 
3940 
3941 # Support macro for PLATFORM_SETUP_OPENJDK_TARGET_BITS.
3942 # Add -mX to various FLAGS variables.
3943 
3944 
3945 
3946 
3947 
3948 
3949 #
3950 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3951 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3952 #
3953 # This code is free software; you can redistribute it and/or modify it
3954 # under the terms of the GNU General Public License version 2 only, as
3955 # published by the Free Software Foundation.  Oracle designates this
3956 # particular file as subject to the "Classpath" exception as provided
3957 # by Oracle in the LICENSE file that accompanied this code.
3958 #
3959 # This code is distributed in the hope that it will be useful, but WITHOUT
3960 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3961 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3962 # version 2 for more details (a copy is included in the LICENSE file that
3963 # accompanied this code).
3964 #
3965 # You should have received a copy of the GNU General Public License version
3966 # 2 along with this work; if not, write to the Free Software Foundation,
3967 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3968 #
3969 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3970 # or visit www.oracle.com if you need additional information or have any
3971 # questions.
3972 #
3973 
3974 
3975 
3976 
3977 
3978 
3979 
3980 
3981 #
3982 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3983 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3984 #
3985 # This code is free software; you can redistribute it and/or modify it
3986 # under the terms of the GNU General Public License version 2 only, as
3987 # published by the Free Software Foundation.  Oracle designates this
3988 # particular file as subject to the "Classpath" exception as provided
3989 # by Oracle in the LICENSE file that accompanied this code.
3990 #
3991 # This code is distributed in the hope that it will be useful, but WITHOUT
3992 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3993 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3994 # version 2 for more details (a copy is included in the LICENSE file that
3995 # accompanied this code).
3996 #
3997 # You should have received a copy of the GNU General Public License version
3998 # 2 along with this work; if not, write to the Free Software Foundation,
3999 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4000 #
4001 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4002 # or visit www.oracle.com if you need additional information or have any
4003 # questions.
4004 #
4005 
4006 # $1 = compiler to test (CC or CXX)
4007 # $2 = human readable name of compiler (C or C++)
4008 
4009 
4010 
4011 
4012 
4013 # $1 = compiler to test (CC or CXX)
4014 # $2 = human readable name of compiler (C or C++)
4015 # $3 = list of compiler names to search for
4016 
4017 
4018 
4019 
4020 
4021 
4022 
4023 
4024 
4025 
4026 
4027 
4028 
4029 # TOOLCHAIN_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
4030 #                                   [RUN-IF-FALSE])
4031 # ------------------------------------------------------------
4032 # Check that the c and c++ compilers support an argument
4033 
4034 
4035 
4036 
4037 # Setup the JTREG paths
4038 
4039 
4040 #
4041 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4042 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4043 #
4044 # This code is free software; you can redistribute it and/or modify it
4045 # under the terms of the GNU General Public License version 2 only, as
4046 # published by the Free Software Foundation.  Oracle designates this
4047 # particular file as subject to the "Classpath" exception as provided
4048 # by Oracle in the LICENSE file that accompanied this code.
4049 #
4050 # This code is distributed in the hope that it will be useful, but WITHOUT
4051 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4052 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4053 # version 2 for more details (a copy is included in the LICENSE file that
4054 # accompanied this code).
4055 #
4056 # You should have received a copy of the GNU General Public License version
4057 # 2 along with this work; if not, write to the Free Software Foundation,
4058 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4059 #
4060 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4061 # or visit www.oracle.com if you need additional information or have any
4062 # questions.
4063 #
4064 
4065 
4066 
4067 
4068 
4069 
4070 
4071 # Check if the VS env variables were setup prior to running configure.
4072 # If not, then find vcvarsall.bat and run it automatically, and integrate
4073 # the set env variables into the spec file.
4074 
4075 
4076 
4077 
4078 
4079 
4080 
4081 
4082 
4083 
4084 # This line needs to be here, verbatim, after all includes and the dummy hook
4085 # definitions. It is replaced with custom functionality when building
4086 # custom sources.
4087 #CUSTOM_AUTOCONF_INCLUDE
4088 
4089 # Do not change or remove the following line, it is needed for consistency checks:
4090 DATE_WHEN_GENERATED=1391160222
4091 
4092 ###############################################################################
4093 #
4094 # Initialization / Boot-strapping
4095 #
4096 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4097 # thus it jumps back and forth, each time gaining something needed later on.
4098 #
4099 ###############################################################################
4100 
4101 # Basic initialization that must happen first of all
4102 
4103   # Save the original command line. This is passed to us by the wrapper configure script.
4104 
4105   DATE_WHEN_CONFIGURED=`LANG=C date`
4106 
4107   { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
4108 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
4109   { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
4110 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
4111 
4112 
4113   # Start with tools that do not need have cross compilation support
4114   # and can be expected to be found in the default PATH. These tools are
4115   # used by configure. Nor are these tools expected to be found in the
4116   # devkit from the builddeps server either, since they are
4117   # needed to download the devkit.
4118 
4119   # First are all the simple required tools.
4120 
4121 
4122 
4123   # Publish this variable in the help.
4124 
4125 
4126   if test "x$BASENAME" = x; then
4127     # The variable is not set by user, try to locate tool using the code snippet
4128     for ac_prog in basename
4129 do
4130   # Extract the first word of "$ac_prog", so it can be a program name with args.
4131 set dummy $ac_prog; ac_word=$2
4132 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4133 $as_echo_n "checking for $ac_word... " >&6; }
4134 if ${ac_cv_path_BASENAME+:} false; then :
4135   $as_echo_n "(cached) " >&6
4136 else
4137   case $BASENAME in
4138   [\\/]* | ?:[\\/]*)
4139   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4140   ;;
4141   *)
4142   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4143 for as_dir in $PATH
4144 do
4145   IFS=$as_save_IFS
4146   test -z "$as_dir" && as_dir=.
4147     for ac_exec_ext in '' $ac_executable_extensions; do
4148   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4149     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4150     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4151     break 2
4152   fi
4153 done
4154   done
4155 IFS=$as_save_IFS
4156 
4157   ;;
4158 esac
4159 fi
4160 BASENAME=$ac_cv_path_BASENAME
4161 if test -n "$BASENAME"; then
4162   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4163 $as_echo "$BASENAME" >&6; }
4164 else
4165   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4166 $as_echo "no" >&6; }
4167 fi
4168 
4169 
4170   test -n "$BASENAME" && break
4171 done
4172 
4173   else
4174     # The variable is set, but is it from the command line or the environment?
4175 
4176     # Try to remove the string !BASENAME! from our list.
4177     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
4178     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4179       # If it failed, the variable was not from the command line. Ignore it,
4180       # but warn the user (except for BASH, which is always set by the calling BASH).
4181       if test "xBASENAME" != xBASH; then
4182         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
4183 $as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
4184       fi
4185       # Try to locate tool using the code snippet
4186       for ac_prog in basename
4187 do
4188   # Extract the first word of "$ac_prog", so it can be a program name with args.
4189 set dummy $ac_prog; ac_word=$2
4190 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4191 $as_echo_n "checking for $ac_word... " >&6; }
4192 if ${ac_cv_path_BASENAME+:} false; then :
4193   $as_echo_n "(cached) " >&6
4194 else
4195   case $BASENAME in
4196   [\\/]* | ?:[\\/]*)
4197   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4198   ;;
4199   *)
4200   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4201 for as_dir in $PATH
4202 do
4203   IFS=$as_save_IFS
4204   test -z "$as_dir" && as_dir=.
4205     for ac_exec_ext in '' $ac_executable_extensions; do
4206   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4207     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4208     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4209     break 2
4210   fi
4211 done
4212   done
4213 IFS=$as_save_IFS
4214 
4215   ;;
4216 esac
4217 fi
4218 BASENAME=$ac_cv_path_BASENAME
4219 if test -n "$BASENAME"; then
4220   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4221 $as_echo "$BASENAME" >&6; }
4222 else
4223   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4224 $as_echo "no" >&6; }
4225 fi
4226 
4227 
4228   test -n "$BASENAME" && break
4229 done
4230 
4231     else
4232       # If it succeeded, then it was overridden by the user. We will use it
4233       # for the tool.
4234 
4235       # First remove it from the list of overridden variables, so we can test
4236       # for unknown variables in the end.
4237       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4238 
4239       # Check if the provided tool contains a complete path.
4240       tool_specified="$BASENAME"
4241       tool_basename="${tool_specified##*/}"
4242       if test "x$tool_basename" = "x$tool_specified"; then
4243         # A command without a complete path is provided, search $PATH.
4244         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
4245 $as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
4246         # Extract the first word of "$tool_basename", so it can be a program name with args.
4247 set dummy $tool_basename; ac_word=$2
4248 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4249 $as_echo_n "checking for $ac_word... " >&6; }
4250 if ${ac_cv_path_BASENAME+:} false; then :
4251   $as_echo_n "(cached) " >&6
4252 else
4253   case $BASENAME in
4254   [\\/]* | ?:[\\/]*)
4255   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4256   ;;
4257   *)
4258   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4259 for as_dir in $PATH
4260 do
4261   IFS=$as_save_IFS
4262   test -z "$as_dir" && as_dir=.
4263     for ac_exec_ext in '' $ac_executable_extensions; do
4264   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4265     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4266     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4267     break 2
4268   fi
4269 done
4270   done
4271 IFS=$as_save_IFS
4272 
4273   ;;
4274 esac
4275 fi
4276 BASENAME=$ac_cv_path_BASENAME
4277 if test -n "$BASENAME"; then
4278   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4279 $as_echo "$BASENAME" >&6; }
4280 else
4281   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4282 $as_echo "no" >&6; }
4283 fi
4284 
4285 
4286         if test "x$BASENAME" = x; then
4287           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4288         fi
4289       else
4290         # Otherwise we believe it is a complete path. Use it as it is.
4291         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
4292 $as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
4293         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
4294 $as_echo_n "checking for BASENAME... " >&6; }
4295         if test ! -x "$tool_specified"; then
4296           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4297 $as_echo "not found" >&6; }
4298           as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
4299         fi
4300         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4301 $as_echo "$tool_specified" >&6; }
4302       fi
4303     fi
4304   fi
4305 
4306 
4307 
4308   if test "x$BASENAME" = x; then
4309     as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
4310   fi
4311 
4312 
4313 
4314 
4315 
4316   # Publish this variable in the help.
4317 
4318 
4319   if test "x$BASH" = x; then
4320     # The variable is not set by user, try to locate tool using the code snippet
4321     for ac_prog in bash
4322 do
4323   # Extract the first word of "$ac_prog", so it can be a program name with args.
4324 set dummy $ac_prog; ac_word=$2
4325 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4326 $as_echo_n "checking for $ac_word... " >&6; }
4327 if ${ac_cv_path_BASH+:} false; then :
4328   $as_echo_n "(cached) " >&6
4329 else
4330   case $BASH in
4331   [\\/]* | ?:[\\/]*)
4332   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4333   ;;
4334   *)
4335   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4336 for as_dir in $PATH
4337 do
4338   IFS=$as_save_IFS
4339   test -z "$as_dir" && as_dir=.
4340     for ac_exec_ext in '' $ac_executable_extensions; do
4341   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4342     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4343     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4344     break 2
4345   fi
4346 done
4347   done
4348 IFS=$as_save_IFS
4349 
4350   ;;
4351 esac
4352 fi
4353 BASH=$ac_cv_path_BASH
4354 if test -n "$BASH"; then
4355   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4356 $as_echo "$BASH" >&6; }
4357 else
4358   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4359 $as_echo "no" >&6; }
4360 fi
4361 
4362 
4363   test -n "$BASH" && break
4364 done
4365 
4366   else
4367     # The variable is set, but is it from the command line or the environment?
4368 
4369     # Try to remove the string !BASH! from our list.
4370     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
4371     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4372       # If it failed, the variable was not from the command line. Ignore it,
4373       # but warn the user (except for BASH, which is always set by the calling BASH).
4374       if test "xBASH" != xBASH; then
4375         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
4376 $as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
4377       fi
4378       # Try to locate tool using the code snippet
4379       for ac_prog in bash
4380 do
4381   # Extract the first word of "$ac_prog", so it can be a program name with args.
4382 set dummy $ac_prog; ac_word=$2
4383 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4384 $as_echo_n "checking for $ac_word... " >&6; }
4385 if ${ac_cv_path_BASH+:} false; then :
4386   $as_echo_n "(cached) " >&6
4387 else
4388   case $BASH in
4389   [\\/]* | ?:[\\/]*)
4390   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4391   ;;
4392   *)
4393   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4394 for as_dir in $PATH
4395 do
4396   IFS=$as_save_IFS
4397   test -z "$as_dir" && as_dir=.
4398     for ac_exec_ext in '' $ac_executable_extensions; do
4399   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4400     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4401     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4402     break 2
4403   fi
4404 done
4405   done
4406 IFS=$as_save_IFS
4407 
4408   ;;
4409 esac
4410 fi
4411 BASH=$ac_cv_path_BASH
4412 if test -n "$BASH"; then
4413   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4414 $as_echo "$BASH" >&6; }
4415 else
4416   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4417 $as_echo "no" >&6; }
4418 fi
4419 
4420 
4421   test -n "$BASH" && break
4422 done
4423 
4424     else
4425       # If it succeeded, then it was overridden by the user. We will use it
4426       # for the tool.
4427 
4428       # First remove it from the list of overridden variables, so we can test
4429       # for unknown variables in the end.
4430       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4431 
4432       # Check if the provided tool contains a complete path.
4433       tool_specified="$BASH"
4434       tool_basename="${tool_specified##*/}"
4435       if test "x$tool_basename" = "x$tool_specified"; then
4436         # A command without a complete path is provided, search $PATH.
4437         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
4438 $as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
4439         # Extract the first word of "$tool_basename", so it can be a program name with args.
4440 set dummy $tool_basename; ac_word=$2
4441 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4442 $as_echo_n "checking for $ac_word... " >&6; }
4443 if ${ac_cv_path_BASH+:} false; then :
4444   $as_echo_n "(cached) " >&6
4445 else
4446   case $BASH in
4447   [\\/]* | ?:[\\/]*)
4448   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4449   ;;
4450   *)
4451   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4452 for as_dir in $PATH
4453 do
4454   IFS=$as_save_IFS
4455   test -z "$as_dir" && as_dir=.
4456     for ac_exec_ext in '' $ac_executable_extensions; do
4457   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4458     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4459     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4460     break 2
4461   fi
4462 done
4463   done
4464 IFS=$as_save_IFS
4465 
4466   ;;
4467 esac
4468 fi
4469 BASH=$ac_cv_path_BASH
4470 if test -n "$BASH"; then
4471   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4472 $as_echo "$BASH" >&6; }
4473 else
4474   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4475 $as_echo "no" >&6; }
4476 fi
4477 
4478 
4479         if test "x$BASH" = x; then
4480           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4481         fi
4482       else
4483         # Otherwise we believe it is a complete path. Use it as it is.
4484         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
4485 $as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
4486         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
4487 $as_echo_n "checking for BASH... " >&6; }
4488         if test ! -x "$tool_specified"; then
4489           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4490 $as_echo "not found" >&6; }
4491           as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
4492         fi
4493         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4494 $as_echo "$tool_specified" >&6; }
4495       fi
4496     fi
4497   fi
4498 
4499 
4500 
4501   if test "x$BASH" = x; then
4502     as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
4503   fi
4504 
4505 
4506 
4507 
4508 
4509   # Publish this variable in the help.
4510 
4511 
4512   if test "x$CAT" = x; then
4513     # The variable is not set by user, try to locate tool using the code snippet
4514     for ac_prog in cat
4515 do
4516   # Extract the first word of "$ac_prog", so it can be a program name with args.
4517 set dummy $ac_prog; ac_word=$2
4518 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4519 $as_echo_n "checking for $ac_word... " >&6; }
4520 if ${ac_cv_path_CAT+:} false; then :
4521   $as_echo_n "(cached) " >&6
4522 else
4523   case $CAT in
4524   [\\/]* | ?:[\\/]*)
4525   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4526   ;;
4527   *)
4528   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4529 for as_dir in $PATH
4530 do
4531   IFS=$as_save_IFS
4532   test -z "$as_dir" && as_dir=.
4533     for ac_exec_ext in '' $ac_executable_extensions; do
4534   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4535     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4536     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4537     break 2
4538   fi
4539 done
4540   done
4541 IFS=$as_save_IFS
4542 
4543   ;;
4544 esac
4545 fi
4546 CAT=$ac_cv_path_CAT
4547 if test -n "$CAT"; then
4548   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4549 $as_echo "$CAT" >&6; }
4550 else
4551   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4552 $as_echo "no" >&6; }
4553 fi
4554 
4555 
4556   test -n "$CAT" && break
4557 done
4558 
4559   else
4560     # The variable is set, but is it from the command line or the environment?
4561 
4562     # Try to remove the string !CAT! from our list.
4563     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
4564     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4565       # If it failed, the variable was not from the command line. Ignore it,
4566       # but warn the user (except for BASH, which is always set by the calling BASH).
4567       if test "xCAT" != xBASH; then
4568         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
4569 $as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
4570       fi
4571       # Try to locate tool using the code snippet
4572       for ac_prog in cat
4573 do
4574   # Extract the first word of "$ac_prog", so it can be a program name with args.
4575 set dummy $ac_prog; ac_word=$2
4576 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4577 $as_echo_n "checking for $ac_word... " >&6; }
4578 if ${ac_cv_path_CAT+:} false; then :
4579   $as_echo_n "(cached) " >&6
4580 else
4581   case $CAT in
4582   [\\/]* | ?:[\\/]*)
4583   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4584   ;;
4585   *)
4586   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4587 for as_dir in $PATH
4588 do
4589   IFS=$as_save_IFS
4590   test -z "$as_dir" && as_dir=.
4591     for ac_exec_ext in '' $ac_executable_extensions; do
4592   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4593     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4594     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4595     break 2
4596   fi
4597 done
4598   done
4599 IFS=$as_save_IFS
4600 
4601   ;;
4602 esac
4603 fi
4604 CAT=$ac_cv_path_CAT
4605 if test -n "$CAT"; then
4606   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4607 $as_echo "$CAT" >&6; }
4608 else
4609   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4610 $as_echo "no" >&6; }
4611 fi
4612 
4613 
4614   test -n "$CAT" && break
4615 done
4616 
4617     else
4618       # If it succeeded, then it was overridden by the user. We will use it
4619       # for the tool.
4620 
4621       # First remove it from the list of overridden variables, so we can test
4622       # for unknown variables in the end.
4623       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4624 
4625       # Check if the provided tool contains a complete path.
4626       tool_specified="$CAT"
4627       tool_basename="${tool_specified##*/}"
4628       if test "x$tool_basename" = "x$tool_specified"; then
4629         # A command without a complete path is provided, search $PATH.
4630         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
4631 $as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
4632         # Extract the first word of "$tool_basename", so it can be a program name with args.
4633 set dummy $tool_basename; ac_word=$2
4634 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4635 $as_echo_n "checking for $ac_word... " >&6; }
4636 if ${ac_cv_path_CAT+:} false; then :
4637   $as_echo_n "(cached) " >&6
4638 else
4639   case $CAT in
4640   [\\/]* | ?:[\\/]*)
4641   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4642   ;;
4643   *)
4644   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4645 for as_dir in $PATH
4646 do
4647   IFS=$as_save_IFS
4648   test -z "$as_dir" && as_dir=.
4649     for ac_exec_ext in '' $ac_executable_extensions; do
4650   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4651     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4652     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4653     break 2
4654   fi
4655 done
4656   done
4657 IFS=$as_save_IFS
4658 
4659   ;;
4660 esac
4661 fi
4662 CAT=$ac_cv_path_CAT
4663 if test -n "$CAT"; then
4664   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4665 $as_echo "$CAT" >&6; }
4666 else
4667   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4668 $as_echo "no" >&6; }
4669 fi
4670 
4671 
4672         if test "x$CAT" = x; then
4673           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4674         fi
4675       else
4676         # Otherwise we believe it is a complete path. Use it as it is.
4677         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
4678 $as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
4679         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
4680 $as_echo_n "checking for CAT... " >&6; }
4681         if test ! -x "$tool_specified"; then
4682           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4683 $as_echo "not found" >&6; }
4684           as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
4685         fi
4686         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4687 $as_echo "$tool_specified" >&6; }
4688       fi
4689     fi
4690   fi
4691 
4692 
4693 
4694   if test "x$CAT" = x; then
4695     as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
4696   fi
4697 
4698 
4699 
4700 
4701 
4702   # Publish this variable in the help.
4703 
4704 
4705   if test "x$CHMOD" = x; then
4706     # The variable is not set by user, try to locate tool using the code snippet
4707     for ac_prog in chmod
4708 do
4709   # Extract the first word of "$ac_prog", so it can be a program name with args.
4710 set dummy $ac_prog; ac_word=$2
4711 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4712 $as_echo_n "checking for $ac_word... " >&6; }
4713 if ${ac_cv_path_CHMOD+:} false; then :
4714   $as_echo_n "(cached) " >&6
4715 else
4716   case $CHMOD in
4717   [\\/]* | ?:[\\/]*)
4718   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
4719   ;;
4720   *)
4721   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4722 for as_dir in $PATH
4723 do
4724   IFS=$as_save_IFS
4725   test -z "$as_dir" && as_dir=.
4726     for ac_exec_ext in '' $ac_executable_extensions; do
4727   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4728     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
4729     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4730     break 2
4731   fi
4732 done
4733   done
4734 IFS=$as_save_IFS
4735 
4736   ;;
4737 esac
4738 fi
4739 CHMOD=$ac_cv_path_CHMOD
4740 if test -n "$CHMOD"; then
4741   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
4742 $as_echo "$CHMOD" >&6; }
4743 else
4744   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4745 $as_echo "no" >&6; }
4746 fi
4747 
4748 
4749   test -n "$CHMOD" && break
4750 done
4751 
4752   else
4753     # The variable is set, but is it from the command line or the environment?
4754 
4755     # Try to remove the string !CHMOD! from our list.
4756     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
4757     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4758       # If it failed, the variable was not from the command line. Ignore it,
4759       # but warn the user (except for BASH, which is always set by the calling BASH).
4760       if test "xCHMOD" != xBASH; then
4761         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
4762 $as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
4763       fi
4764       # Try to locate tool using the code snippet
4765       for ac_prog in chmod
4766 do
4767   # Extract the first word of "$ac_prog", so it can be a program name with args.
4768 set dummy $ac_prog; ac_word=$2
4769 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4770 $as_echo_n "checking for $ac_word... " >&6; }
4771 if ${ac_cv_path_CHMOD+:} false; then :
4772   $as_echo_n "(cached) " >&6
4773 else
4774   case $CHMOD in
4775   [\\/]* | ?:[\\/]*)
4776   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
4777   ;;
4778   *)
4779   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4780 for as_dir in $PATH
4781 do
4782   IFS=$as_save_IFS
4783   test -z "$as_dir" && as_dir=.
4784     for ac_exec_ext in '' $ac_executable_extensions; do
4785   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4786     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
4787     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4788     break 2
4789   fi
4790 done
4791   done
4792 IFS=$as_save_IFS
4793 
4794   ;;
4795 esac
4796 fi
4797 CHMOD=$ac_cv_path_CHMOD
4798 if test -n "$CHMOD"; then
4799   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
4800 $as_echo "$CHMOD" >&6; }
4801 else
4802   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4803 $as_echo "no" >&6; }
4804 fi
4805 
4806 
4807   test -n "$CHMOD" && break
4808 done
4809 
4810     else
4811       # If it succeeded, then it was overridden by the user. We will use it
4812       # for the tool.
4813 
4814       # First remove it from the list of overridden variables, so we can test
4815       # for unknown variables in the end.
4816       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4817 
4818       # Check if the provided tool contains a complete path.
4819       tool_specified="$CHMOD"
4820       tool_basename="${tool_specified##*/}"
4821       if test "x$tool_basename" = "x$tool_specified"; then
4822         # A command without a complete path is provided, search $PATH.
4823         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
4824 $as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
4825         # Extract the first word of "$tool_basename", so it can be a program name with args.
4826 set dummy $tool_basename; ac_word=$2
4827 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4828 $as_echo_n "checking for $ac_word... " >&6; }
4829 if ${ac_cv_path_CHMOD+:} false; then :
4830   $as_echo_n "(cached) " >&6
4831 else
4832   case $CHMOD in
4833   [\\/]* | ?:[\\/]*)
4834   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
4835   ;;
4836   *)
4837   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4838 for as_dir in $PATH
4839 do
4840   IFS=$as_save_IFS
4841   test -z "$as_dir" && as_dir=.
4842     for ac_exec_ext in '' $ac_executable_extensions; do
4843   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4844     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
4845     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4846     break 2
4847   fi
4848 done
4849   done
4850 IFS=$as_save_IFS
4851 
4852   ;;
4853 esac
4854 fi
4855 CHMOD=$ac_cv_path_CHMOD
4856 if test -n "$CHMOD"; then
4857   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
4858 $as_echo "$CHMOD" >&6; }
4859 else
4860   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4861 $as_echo "no" >&6; }
4862 fi
4863 
4864 
4865         if test "x$CHMOD" = x; then
4866           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4867         fi
4868       else
4869         # Otherwise we believe it is a complete path. Use it as it is.
4870         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
4871 $as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
4872         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
4873 $as_echo_n "checking for CHMOD... " >&6; }
4874         if test ! -x "$tool_specified"; then
4875           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4876 $as_echo "not found" >&6; }
4877           as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
4878         fi
4879         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4880 $as_echo "$tool_specified" >&6; }
4881       fi
4882     fi
4883   fi
4884 
4885 
4886 
4887   if test "x$CHMOD" = x; then
4888     as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
4889   fi
4890 
4891 
4892 
4893 
4894 
4895   # Publish this variable in the help.
4896 
4897 
4898   if test "x$CMP" = x; then
4899     # The variable is not set by user, try to locate tool using the code snippet
4900     for ac_prog in cmp
4901 do
4902   # Extract the first word of "$ac_prog", so it can be a program name with args.
4903 set dummy $ac_prog; ac_word=$2
4904 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4905 $as_echo_n "checking for $ac_word... " >&6; }
4906 if ${ac_cv_path_CMP+:} false; then :
4907   $as_echo_n "(cached) " >&6
4908 else
4909   case $CMP in
4910   [\\/]* | ?:[\\/]*)
4911   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
4912   ;;
4913   *)
4914   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4915 for as_dir in $PATH
4916 do
4917   IFS=$as_save_IFS
4918   test -z "$as_dir" && as_dir=.
4919     for ac_exec_ext in '' $ac_executable_extensions; do
4920   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4921     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
4922     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4923     break 2
4924   fi
4925 done
4926   done
4927 IFS=$as_save_IFS
4928 
4929   ;;
4930 esac
4931 fi
4932 CMP=$ac_cv_path_CMP
4933 if test -n "$CMP"; then
4934   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
4935 $as_echo "$CMP" >&6; }
4936 else
4937   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4938 $as_echo "no" >&6; }
4939 fi
4940 
4941 
4942   test -n "$CMP" && break
4943 done
4944 
4945   else
4946     # The variable is set, but is it from the command line or the environment?
4947 
4948     # Try to remove the string !CMP! from our list.
4949     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
4950     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4951       # If it failed, the variable was not from the command line. Ignore it,
4952       # but warn the user (except for BASH, which is always set by the calling BASH).
4953       if test "xCMP" != xBASH; then
4954         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
4955 $as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
4956       fi
4957       # Try to locate tool using the code snippet
4958       for ac_prog in cmp
4959 do
4960   # Extract the first word of "$ac_prog", so it can be a program name with args.
4961 set dummy $ac_prog; ac_word=$2
4962 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4963 $as_echo_n "checking for $ac_word... " >&6; }
4964 if ${ac_cv_path_CMP+:} false; then :
4965   $as_echo_n "(cached) " >&6
4966 else
4967   case $CMP in
4968   [\\/]* | ?:[\\/]*)
4969   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
4970   ;;
4971   *)
4972   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4973 for as_dir in $PATH
4974 do
4975   IFS=$as_save_IFS
4976   test -z "$as_dir" && as_dir=.
4977     for ac_exec_ext in '' $ac_executable_extensions; do
4978   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4979     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
4980     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4981     break 2
4982   fi
4983 done
4984   done
4985 IFS=$as_save_IFS
4986 
4987   ;;
4988 esac
4989 fi
4990 CMP=$ac_cv_path_CMP
4991 if test -n "$CMP"; then
4992   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
4993 $as_echo "$CMP" >&6; }
4994 else
4995   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4996 $as_echo "no" >&6; }
4997 fi
4998 
4999 
5000   test -n "$CMP" && break
5001 done
5002 
5003     else
5004       # If it succeeded, then it was overridden by the user. We will use it
5005       # for the tool.
5006 
5007       # First remove it from the list of overridden variables, so we can test
5008       # for unknown variables in the end.
5009       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5010 
5011       # Check if the provided tool contains a complete path.
5012       tool_specified="$CMP"
5013       tool_basename="${tool_specified##*/}"
5014       if test "x$tool_basename" = "x$tool_specified"; then
5015         # A command without a complete path is provided, search $PATH.
5016         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
5017 $as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
5018         # Extract the first word of "$tool_basename", so it can be a program name with args.
5019 set dummy $tool_basename; ac_word=$2
5020 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5021 $as_echo_n "checking for $ac_word... " >&6; }
5022 if ${ac_cv_path_CMP+:} false; then :
5023   $as_echo_n "(cached) " >&6
5024 else
5025   case $CMP in
5026   [\\/]* | ?:[\\/]*)
5027   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5028   ;;
5029   *)
5030   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5031 for as_dir in $PATH
5032 do
5033   IFS=$as_save_IFS
5034   test -z "$as_dir" && as_dir=.
5035     for ac_exec_ext in '' $ac_executable_extensions; do
5036   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5037     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5038     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5039     break 2
5040   fi
5041 done
5042   done
5043 IFS=$as_save_IFS
5044 
5045   ;;
5046 esac
5047 fi
5048 CMP=$ac_cv_path_CMP
5049 if test -n "$CMP"; then
5050   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5051 $as_echo "$CMP" >&6; }
5052 else
5053   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5054 $as_echo "no" >&6; }
5055 fi
5056 
5057 
5058         if test "x$CMP" = x; then
5059           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5060         fi
5061       else
5062         # Otherwise we believe it is a complete path. Use it as it is.
5063         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
5064 $as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
5065         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
5066 $as_echo_n "checking for CMP... " >&6; }
5067         if test ! -x "$tool_specified"; then
5068           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5069 $as_echo "not found" >&6; }
5070           as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
5071         fi
5072         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5073 $as_echo "$tool_specified" >&6; }
5074       fi
5075     fi
5076   fi
5077 
5078 
5079 
5080   if test "x$CMP" = x; then
5081     as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
5082   fi
5083 
5084 
5085 
5086 
5087 
5088   # Publish this variable in the help.
5089 
5090 
5091   if test "x$COMM" = x; then
5092     # The variable is not set by user, try to locate tool using the code snippet
5093     for ac_prog in comm
5094 do
5095   # Extract the first word of "$ac_prog", so it can be a program name with args.
5096 set dummy $ac_prog; ac_word=$2
5097 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5098 $as_echo_n "checking for $ac_word... " >&6; }
5099 if ${ac_cv_path_COMM+:} false; then :
5100   $as_echo_n "(cached) " >&6
5101 else
5102   case $COMM in
5103   [\\/]* | ?:[\\/]*)
5104   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5105   ;;
5106   *)
5107   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5108 for as_dir in $PATH
5109 do
5110   IFS=$as_save_IFS
5111   test -z "$as_dir" && as_dir=.
5112     for ac_exec_ext in '' $ac_executable_extensions; do
5113   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5114     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5115     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5116     break 2
5117   fi
5118 done
5119   done
5120 IFS=$as_save_IFS
5121 
5122   ;;
5123 esac
5124 fi
5125 COMM=$ac_cv_path_COMM
5126 if test -n "$COMM"; then
5127   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5128 $as_echo "$COMM" >&6; }
5129 else
5130   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5131 $as_echo "no" >&6; }
5132 fi
5133 
5134 
5135   test -n "$COMM" && break
5136 done
5137 
5138   else
5139     # The variable is set, but is it from the command line or the environment?
5140 
5141     # Try to remove the string !COMM! from our list.
5142     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
5143     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5144       # If it failed, the variable was not from the command line. Ignore it,
5145       # but warn the user (except for BASH, which is always set by the calling BASH).
5146       if test "xCOMM" != xBASH; then
5147         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
5148 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
5149       fi
5150       # Try to locate tool using the code snippet
5151       for ac_prog in comm
5152 do
5153   # Extract the first word of "$ac_prog", so it can be a program name with args.
5154 set dummy $ac_prog; ac_word=$2
5155 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5156 $as_echo_n "checking for $ac_word... " >&6; }
5157 if ${ac_cv_path_COMM+:} false; then :
5158   $as_echo_n "(cached) " >&6
5159 else
5160   case $COMM in
5161   [\\/]* | ?:[\\/]*)
5162   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5163   ;;
5164   *)
5165   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5166 for as_dir in $PATH
5167 do
5168   IFS=$as_save_IFS
5169   test -z "$as_dir" && as_dir=.
5170     for ac_exec_ext in '' $ac_executable_extensions; do
5171   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5172     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5173     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5174     break 2
5175   fi
5176 done
5177   done
5178 IFS=$as_save_IFS
5179 
5180   ;;
5181 esac
5182 fi
5183 COMM=$ac_cv_path_COMM
5184 if test -n "$COMM"; then
5185   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5186 $as_echo "$COMM" >&6; }
5187 else
5188   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5189 $as_echo "no" >&6; }
5190 fi
5191 
5192 
5193   test -n "$COMM" && break
5194 done
5195 
5196     else
5197       # If it succeeded, then it was overridden by the user. We will use it
5198       # for the tool.
5199 
5200       # First remove it from the list of overridden variables, so we can test
5201       # for unknown variables in the end.
5202       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5203 
5204       # Check if the provided tool contains a complete path.
5205       tool_specified="$COMM"
5206       tool_basename="${tool_specified##*/}"
5207       if test "x$tool_basename" = "x$tool_specified"; then
5208         # A command without a complete path is provided, search $PATH.
5209         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
5210 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
5211         # Extract the first word of "$tool_basename", so it can be a program name with args.
5212 set dummy $tool_basename; ac_word=$2
5213 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5214 $as_echo_n "checking for $ac_word... " >&6; }
5215 if ${ac_cv_path_COMM+:} false; then :
5216   $as_echo_n "(cached) " >&6
5217 else
5218   case $COMM in
5219   [\\/]* | ?:[\\/]*)
5220   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5221   ;;
5222   *)
5223   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5224 for as_dir in $PATH
5225 do
5226   IFS=$as_save_IFS
5227   test -z "$as_dir" && as_dir=.
5228     for ac_exec_ext in '' $ac_executable_extensions; do
5229   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5230     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5231     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5232     break 2
5233   fi
5234 done
5235   done
5236 IFS=$as_save_IFS
5237 
5238   ;;
5239 esac
5240 fi
5241 COMM=$ac_cv_path_COMM
5242 if test -n "$COMM"; then
5243   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5244 $as_echo "$COMM" >&6; }
5245 else
5246   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5247 $as_echo "no" >&6; }
5248 fi
5249 
5250 
5251         if test "x$COMM" = x; then
5252           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5253         fi
5254       else
5255         # Otherwise we believe it is a complete path. Use it as it is.
5256         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
5257 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
5258         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
5259 $as_echo_n "checking for COMM... " >&6; }
5260         if test ! -x "$tool_specified"; then
5261           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5262 $as_echo "not found" >&6; }
5263           as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
5264         fi
5265         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5266 $as_echo "$tool_specified" >&6; }
5267       fi
5268     fi
5269   fi
5270 
5271 
5272 
5273   if test "x$COMM" = x; then
5274     as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
5275   fi
5276 
5277 
5278 
5279 
5280 
5281   # Publish this variable in the help.
5282 
5283 
5284   if test "x$CP" = x; then
5285     # The variable is not set by user, try to locate tool using the code snippet
5286     for ac_prog in cp
5287 do
5288   # Extract the first word of "$ac_prog", so it can be a program name with args.
5289 set dummy $ac_prog; ac_word=$2
5290 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5291 $as_echo_n "checking for $ac_word... " >&6; }
5292 if ${ac_cv_path_CP+:} false; then :
5293   $as_echo_n "(cached) " >&6
5294 else
5295   case $CP in
5296   [\\/]* | ?:[\\/]*)
5297   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5298   ;;
5299   *)
5300   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5301 for as_dir in $PATH
5302 do
5303   IFS=$as_save_IFS
5304   test -z "$as_dir" && as_dir=.
5305     for ac_exec_ext in '' $ac_executable_extensions; do
5306   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5307     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5308     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5309     break 2
5310   fi
5311 done
5312   done
5313 IFS=$as_save_IFS
5314 
5315   ;;
5316 esac
5317 fi
5318 CP=$ac_cv_path_CP
5319 if test -n "$CP"; then
5320   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5321 $as_echo "$CP" >&6; }
5322 else
5323   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5324 $as_echo "no" >&6; }
5325 fi
5326 
5327 
5328   test -n "$CP" && break
5329 done
5330 
5331   else
5332     # The variable is set, but is it from the command line or the environment?
5333 
5334     # Try to remove the string !CP! from our list.
5335     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
5336     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5337       # If it failed, the variable was not from the command line. Ignore it,
5338       # but warn the user (except for BASH, which is always set by the calling BASH).
5339       if test "xCP" != xBASH; then
5340         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
5341 $as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
5342       fi
5343       # Try to locate tool using the code snippet
5344       for ac_prog in cp
5345 do
5346   # Extract the first word of "$ac_prog", so it can be a program name with args.
5347 set dummy $ac_prog; ac_word=$2
5348 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5349 $as_echo_n "checking for $ac_word... " >&6; }
5350 if ${ac_cv_path_CP+:} false; then :
5351   $as_echo_n "(cached) " >&6
5352 else
5353   case $CP in
5354   [\\/]* | ?:[\\/]*)
5355   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5356   ;;
5357   *)
5358   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5359 for as_dir in $PATH
5360 do
5361   IFS=$as_save_IFS
5362   test -z "$as_dir" && as_dir=.
5363     for ac_exec_ext in '' $ac_executable_extensions; do
5364   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5365     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5366     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5367     break 2
5368   fi
5369 done
5370   done
5371 IFS=$as_save_IFS
5372 
5373   ;;
5374 esac
5375 fi
5376 CP=$ac_cv_path_CP
5377 if test -n "$CP"; then
5378   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5379 $as_echo "$CP" >&6; }
5380 else
5381   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5382 $as_echo "no" >&6; }
5383 fi
5384 
5385 
5386   test -n "$CP" && break
5387 done
5388 
5389     else
5390       # If it succeeded, then it was overridden by the user. We will use it
5391       # for the tool.
5392 
5393       # First remove it from the list of overridden variables, so we can test
5394       # for unknown variables in the end.
5395       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5396 
5397       # Check if the provided tool contains a complete path.
5398       tool_specified="$CP"
5399       tool_basename="${tool_specified##*/}"
5400       if test "x$tool_basename" = "x$tool_specified"; then
5401         # A command without a complete path is provided, search $PATH.
5402         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
5403 $as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
5404         # Extract the first word of "$tool_basename", so it can be a program name with args.
5405 set dummy $tool_basename; ac_word=$2
5406 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5407 $as_echo_n "checking for $ac_word... " >&6; }
5408 if ${ac_cv_path_CP+:} false; then :
5409   $as_echo_n "(cached) " >&6
5410 else
5411   case $CP in
5412   [\\/]* | ?:[\\/]*)
5413   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5414   ;;
5415   *)
5416   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5417 for as_dir in $PATH
5418 do
5419   IFS=$as_save_IFS
5420   test -z "$as_dir" && as_dir=.
5421     for ac_exec_ext in '' $ac_executable_extensions; do
5422   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5423     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5424     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5425     break 2
5426   fi
5427 done
5428   done
5429 IFS=$as_save_IFS
5430 
5431   ;;
5432 esac
5433 fi
5434 CP=$ac_cv_path_CP
5435 if test -n "$CP"; then
5436   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5437 $as_echo "$CP" >&6; }
5438 else
5439   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5440 $as_echo "no" >&6; }
5441 fi
5442 
5443 
5444         if test "x$CP" = x; then
5445           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5446         fi
5447       else
5448         # Otherwise we believe it is a complete path. Use it as it is.
5449         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
5450 $as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
5451         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
5452 $as_echo_n "checking for CP... " >&6; }
5453         if test ! -x "$tool_specified"; then
5454           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5455 $as_echo "not found" >&6; }
5456           as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
5457         fi
5458         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5459 $as_echo "$tool_specified" >&6; }
5460       fi
5461     fi
5462   fi
5463 
5464 
5465 
5466   if test "x$CP" = x; then
5467     as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
5468   fi
5469 
5470 
5471 
5472 
5473 
5474   # Publish this variable in the help.
5475 
5476 
5477   if test "x$CPIO" = x; then
5478     # The variable is not set by user, try to locate tool using the code snippet
5479     for ac_prog in cpio
5480 do
5481   # Extract the first word of "$ac_prog", so it can be a program name with args.
5482 set dummy $ac_prog; ac_word=$2
5483 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5484 $as_echo_n "checking for $ac_word... " >&6; }
5485 if ${ac_cv_path_CPIO+:} false; then :
5486   $as_echo_n "(cached) " >&6
5487 else
5488   case $CPIO in
5489   [\\/]* | ?:[\\/]*)
5490   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
5491   ;;
5492   *)
5493   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5494 for as_dir in $PATH
5495 do
5496   IFS=$as_save_IFS
5497   test -z "$as_dir" && as_dir=.
5498     for ac_exec_ext in '' $ac_executable_extensions; do
5499   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5500     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
5501     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5502     break 2
5503   fi
5504 done
5505   done
5506 IFS=$as_save_IFS
5507 
5508   ;;
5509 esac
5510 fi
5511 CPIO=$ac_cv_path_CPIO
5512 if test -n "$CPIO"; then
5513   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
5514 $as_echo "$CPIO" >&6; }
5515 else
5516   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5517 $as_echo "no" >&6; }
5518 fi
5519 
5520 
5521   test -n "$CPIO" && break
5522 done
5523 
5524   else
5525     # The variable is set, but is it from the command line or the environment?
5526 
5527     # Try to remove the string !CPIO! from our list.
5528     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
5529     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5530       # If it failed, the variable was not from the command line. Ignore it,
5531       # but warn the user (except for BASH, which is always set by the calling BASH).
5532       if test "xCPIO" != xBASH; then
5533         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
5534 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
5535       fi
5536       # Try to locate tool using the code snippet
5537       for ac_prog in cpio
5538 do
5539   # Extract the first word of "$ac_prog", so it can be a program name with args.
5540 set dummy $ac_prog; ac_word=$2
5541 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5542 $as_echo_n "checking for $ac_word... " >&6; }
5543 if ${ac_cv_path_CPIO+:} false; then :
5544   $as_echo_n "(cached) " >&6
5545 else
5546   case $CPIO in
5547   [\\/]* | ?:[\\/]*)
5548   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
5549   ;;
5550   *)
5551   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5552 for as_dir in $PATH
5553 do
5554   IFS=$as_save_IFS
5555   test -z "$as_dir" && as_dir=.
5556     for ac_exec_ext in '' $ac_executable_extensions; do
5557   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5558     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
5559     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5560     break 2
5561   fi
5562 done
5563   done
5564 IFS=$as_save_IFS
5565 
5566   ;;
5567 esac
5568 fi
5569 CPIO=$ac_cv_path_CPIO
5570 if test -n "$CPIO"; then
5571   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
5572 $as_echo "$CPIO" >&6; }
5573 else
5574   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5575 $as_echo "no" >&6; }
5576 fi
5577 
5578 
5579   test -n "$CPIO" && break
5580 done
5581 
5582     else
5583       # If it succeeded, then it was overridden by the user. We will use it
5584       # for the tool.
5585 
5586       # First remove it from the list of overridden variables, so we can test
5587       # for unknown variables in the end.
5588       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5589 
5590       # Check if the provided tool contains a complete path.
5591       tool_specified="$CPIO"
5592       tool_basename="${tool_specified##*/}"
5593       if test "x$tool_basename" = "x$tool_specified"; then
5594         # A command without a complete path is provided, search $PATH.
5595         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
5596 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
5597         # Extract the first word of "$tool_basename", so it can be a program name with args.
5598 set dummy $tool_basename; ac_word=$2
5599 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5600 $as_echo_n "checking for $ac_word... " >&6; }
5601 if ${ac_cv_path_CPIO+:} false; then :
5602   $as_echo_n "(cached) " >&6
5603 else
5604   case $CPIO in
5605   [\\/]* | ?:[\\/]*)
5606   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
5607   ;;
5608   *)
5609   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5610 for as_dir in $PATH
5611 do
5612   IFS=$as_save_IFS
5613   test -z "$as_dir" && as_dir=.
5614     for ac_exec_ext in '' $ac_executable_extensions; do
5615   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5616     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
5617     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5618     break 2
5619   fi
5620 done
5621   done
5622 IFS=$as_save_IFS
5623 
5624   ;;
5625 esac
5626 fi
5627 CPIO=$ac_cv_path_CPIO
5628 if test -n "$CPIO"; then
5629   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
5630 $as_echo "$CPIO" >&6; }
5631 else
5632   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5633 $as_echo "no" >&6; }
5634 fi
5635 
5636 
5637         if test "x$CPIO" = x; then
5638           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5639         fi
5640       else
5641         # Otherwise we believe it is a complete path. Use it as it is.
5642         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
5643 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
5644         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
5645 $as_echo_n "checking for CPIO... " >&6; }
5646         if test ! -x "$tool_specified"; then
5647           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5648 $as_echo "not found" >&6; }
5649           as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
5650         fi
5651         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5652 $as_echo "$tool_specified" >&6; }
5653       fi
5654     fi
5655   fi
5656 
5657 
5658 
5659   if test "x$CPIO" = x; then
5660     as_fn_error $? "Could not find required tool for CPIO" "$LINENO" 5
5661   fi
5662 
5663 
5664 
5665 
5666 
5667   # Publish this variable in the help.
5668 
5669 
5670   if test "x$CUT" = x; then
5671     # The variable is not set by user, try to locate tool using the code snippet
5672     for ac_prog in cut
5673 do
5674   # Extract the first word of "$ac_prog", so it can be a program name with args.
5675 set dummy $ac_prog; ac_word=$2
5676 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5677 $as_echo_n "checking for $ac_word... " >&6; }
5678 if ${ac_cv_path_CUT+:} false; then :
5679   $as_echo_n "(cached) " >&6
5680 else
5681   case $CUT in
5682   [\\/]* | ?:[\\/]*)
5683   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5684   ;;
5685   *)
5686   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5687 for as_dir in $PATH
5688 do
5689   IFS=$as_save_IFS
5690   test -z "$as_dir" && as_dir=.
5691     for ac_exec_ext in '' $ac_executable_extensions; do
5692   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5693     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5694     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5695     break 2
5696   fi
5697 done
5698   done
5699 IFS=$as_save_IFS
5700 
5701   ;;
5702 esac
5703 fi
5704 CUT=$ac_cv_path_CUT
5705 if test -n "$CUT"; then
5706   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5707 $as_echo "$CUT" >&6; }
5708 else
5709   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5710 $as_echo "no" >&6; }
5711 fi
5712 
5713 
5714   test -n "$CUT" && break
5715 done
5716 
5717   else
5718     # The variable is set, but is it from the command line or the environment?
5719 
5720     # Try to remove the string !CUT! from our list.
5721     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
5722     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5723       # If it failed, the variable was not from the command line. Ignore it,
5724       # but warn the user (except for BASH, which is always set by the calling BASH).
5725       if test "xCUT" != xBASH; then
5726         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
5727 $as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
5728       fi
5729       # Try to locate tool using the code snippet
5730       for ac_prog in cut
5731 do
5732   # Extract the first word of "$ac_prog", so it can be a program name with args.
5733 set dummy $ac_prog; ac_word=$2
5734 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5735 $as_echo_n "checking for $ac_word... " >&6; }
5736 if ${ac_cv_path_CUT+:} false; then :
5737   $as_echo_n "(cached) " >&6
5738 else
5739   case $CUT in
5740   [\\/]* | ?:[\\/]*)
5741   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5742   ;;
5743   *)
5744   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5745 for as_dir in $PATH
5746 do
5747   IFS=$as_save_IFS
5748   test -z "$as_dir" && as_dir=.
5749     for ac_exec_ext in '' $ac_executable_extensions; do
5750   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5751     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5752     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5753     break 2
5754   fi
5755 done
5756   done
5757 IFS=$as_save_IFS
5758 
5759   ;;
5760 esac
5761 fi
5762 CUT=$ac_cv_path_CUT
5763 if test -n "$CUT"; then
5764   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5765 $as_echo "$CUT" >&6; }
5766 else
5767   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5768 $as_echo "no" >&6; }
5769 fi
5770 
5771 
5772   test -n "$CUT" && break
5773 done
5774 
5775     else
5776       # If it succeeded, then it was overridden by the user. We will use it
5777       # for the tool.
5778 
5779       # First remove it from the list of overridden variables, so we can test
5780       # for unknown variables in the end.
5781       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5782 
5783       # Check if the provided tool contains a complete path.
5784       tool_specified="$CUT"
5785       tool_basename="${tool_specified##*/}"
5786       if test "x$tool_basename" = "x$tool_specified"; then
5787         # A command without a complete path is provided, search $PATH.
5788         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
5789 $as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
5790         # Extract the first word of "$tool_basename", so it can be a program name with args.
5791 set dummy $tool_basename; ac_word=$2
5792 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5793 $as_echo_n "checking for $ac_word... " >&6; }
5794 if ${ac_cv_path_CUT+:} false; then :
5795   $as_echo_n "(cached) " >&6
5796 else
5797   case $CUT in
5798   [\\/]* | ?:[\\/]*)
5799   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5800   ;;
5801   *)
5802   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5803 for as_dir in $PATH
5804 do
5805   IFS=$as_save_IFS
5806   test -z "$as_dir" && as_dir=.
5807     for ac_exec_ext in '' $ac_executable_extensions; do
5808   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5809     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5810     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5811     break 2
5812   fi
5813 done
5814   done
5815 IFS=$as_save_IFS
5816 
5817   ;;
5818 esac
5819 fi
5820 CUT=$ac_cv_path_CUT
5821 if test -n "$CUT"; then
5822   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5823 $as_echo "$CUT" >&6; }
5824 else
5825   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5826 $as_echo "no" >&6; }
5827 fi
5828 
5829 
5830         if test "x$CUT" = x; then
5831           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5832         fi
5833       else
5834         # Otherwise we believe it is a complete path. Use it as it is.
5835         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
5836 $as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
5837         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
5838 $as_echo_n "checking for CUT... " >&6; }
5839         if test ! -x "$tool_specified"; then
5840           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5841 $as_echo "not found" >&6; }
5842           as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
5843         fi
5844         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5845 $as_echo "$tool_specified" >&6; }
5846       fi
5847     fi
5848   fi
5849 
5850 
5851 
5852   if test "x$CUT" = x; then
5853     as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
5854   fi
5855 
5856 
5857 
5858 
5859 
5860   # Publish this variable in the help.
5861 
5862 
5863   if test "x$DATE" = x; then
5864     # The variable is not set by user, try to locate tool using the code snippet
5865     for ac_prog in date
5866 do
5867   # Extract the first word of "$ac_prog", so it can be a program name with args.
5868 set dummy $ac_prog; ac_word=$2
5869 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5870 $as_echo_n "checking for $ac_word... " >&6; }
5871 if ${ac_cv_path_DATE+:} false; then :
5872   $as_echo_n "(cached) " >&6
5873 else
5874   case $DATE in
5875   [\\/]* | ?:[\\/]*)
5876   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
5877   ;;
5878   *)
5879   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5880 for as_dir in $PATH
5881 do
5882   IFS=$as_save_IFS
5883   test -z "$as_dir" && as_dir=.
5884     for ac_exec_ext in '' $ac_executable_extensions; do
5885   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5886     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
5887     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5888     break 2
5889   fi
5890 done
5891   done
5892 IFS=$as_save_IFS
5893 
5894   ;;
5895 esac
5896 fi
5897 DATE=$ac_cv_path_DATE
5898 if test -n "$DATE"; then
5899   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
5900 $as_echo "$DATE" >&6; }
5901 else
5902   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5903 $as_echo "no" >&6; }
5904 fi
5905 
5906 
5907   test -n "$DATE" && break
5908 done
5909 
5910   else
5911     # The variable is set, but is it from the command line or the environment?
5912 
5913     # Try to remove the string !DATE! from our list.
5914     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
5915     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5916       # If it failed, the variable was not from the command line. Ignore it,
5917       # but warn the user (except for BASH, which is always set by the calling BASH).
5918       if test "xDATE" != xBASH; then
5919         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
5920 $as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
5921       fi
5922       # Try to locate tool using the code snippet
5923       for ac_prog in date
5924 do
5925   # Extract the first word of "$ac_prog", so it can be a program name with args.
5926 set dummy $ac_prog; ac_word=$2
5927 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5928 $as_echo_n "checking for $ac_word... " >&6; }
5929 if ${ac_cv_path_DATE+:} false; then :
5930   $as_echo_n "(cached) " >&6
5931 else
5932   case $DATE in
5933   [\\/]* | ?:[\\/]*)
5934   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
5935   ;;
5936   *)
5937   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5938 for as_dir in $PATH
5939 do
5940   IFS=$as_save_IFS
5941   test -z "$as_dir" && as_dir=.
5942     for ac_exec_ext in '' $ac_executable_extensions; do
5943   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5944     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
5945     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5946     break 2
5947   fi
5948 done
5949   done
5950 IFS=$as_save_IFS
5951 
5952   ;;
5953 esac
5954 fi
5955 DATE=$ac_cv_path_DATE
5956 if test -n "$DATE"; then
5957   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
5958 $as_echo "$DATE" >&6; }
5959 else
5960   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5961 $as_echo "no" >&6; }
5962 fi
5963 
5964 
5965   test -n "$DATE" && break
5966 done
5967 
5968     else
5969       # If it succeeded, then it was overridden by the user. We will use it
5970       # for the tool.
5971 
5972       # First remove it from the list of overridden variables, so we can test
5973       # for unknown variables in the end.
5974       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5975 
5976       # Check if the provided tool contains a complete path.
5977       tool_specified="$DATE"
5978       tool_basename="${tool_specified##*/}"
5979       if test "x$tool_basename" = "x$tool_specified"; then
5980         # A command without a complete path is provided, search $PATH.
5981         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
5982 $as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
5983         # Extract the first word of "$tool_basename", so it can be a program name with args.
5984 set dummy $tool_basename; ac_word=$2
5985 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5986 $as_echo_n "checking for $ac_word... " >&6; }
5987 if ${ac_cv_path_DATE+:} false; then :
5988   $as_echo_n "(cached) " >&6
5989 else
5990   case $DATE in
5991   [\\/]* | ?:[\\/]*)
5992   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
5993   ;;
5994   *)
5995   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5996 for as_dir in $PATH
5997 do
5998   IFS=$as_save_IFS
5999   test -z "$as_dir" && as_dir=.
6000     for ac_exec_ext in '' $ac_executable_extensions; do
6001   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6002     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6003     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6004     break 2
6005   fi
6006 done
6007   done
6008 IFS=$as_save_IFS
6009 
6010   ;;
6011 esac
6012 fi
6013 DATE=$ac_cv_path_DATE
6014 if test -n "$DATE"; then
6015   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6016 $as_echo "$DATE" >&6; }
6017 else
6018   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6019 $as_echo "no" >&6; }
6020 fi
6021 
6022 
6023         if test "x$DATE" = x; then
6024           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6025         fi
6026       else
6027         # Otherwise we believe it is a complete path. Use it as it is.
6028         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
6029 $as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
6030         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6031 $as_echo_n "checking for DATE... " >&6; }
6032         if test ! -x "$tool_specified"; then
6033           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6034 $as_echo "not found" >&6; }
6035           as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
6036         fi
6037         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6038 $as_echo "$tool_specified" >&6; }
6039       fi
6040     fi
6041   fi
6042 
6043 
6044 
6045   if test "x$DATE" = x; then
6046     as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
6047   fi
6048 
6049 
6050 
6051 
6052 
6053   # Publish this variable in the help.
6054 
6055 
6056   if test "x$DIFF" = x; then
6057     # The variable is not set by user, try to locate tool using the code snippet
6058     for ac_prog in gdiff diff
6059 do
6060   # Extract the first word of "$ac_prog", so it can be a program name with args.
6061 set dummy $ac_prog; ac_word=$2
6062 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6063 $as_echo_n "checking for $ac_word... " >&6; }
6064 if ${ac_cv_path_DIFF+:} false; then :
6065   $as_echo_n "(cached) " >&6
6066 else
6067   case $DIFF in
6068   [\\/]* | ?:[\\/]*)
6069   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6070   ;;
6071   *)
6072   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6073 for as_dir in $PATH
6074 do
6075   IFS=$as_save_IFS
6076   test -z "$as_dir" && as_dir=.
6077     for ac_exec_ext in '' $ac_executable_extensions; do
6078   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6079     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6080     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6081     break 2
6082   fi
6083 done
6084   done
6085 IFS=$as_save_IFS
6086 
6087   ;;
6088 esac
6089 fi
6090 DIFF=$ac_cv_path_DIFF
6091 if test -n "$DIFF"; then
6092   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6093 $as_echo "$DIFF" >&6; }
6094 else
6095   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6096 $as_echo "no" >&6; }
6097 fi
6098 
6099 
6100   test -n "$DIFF" && break
6101 done
6102 
6103   else
6104     # The variable is set, but is it from the command line or the environment?
6105 
6106     # Try to remove the string !DIFF! from our list.
6107     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
6108     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6109       # If it failed, the variable was not from the command line. Ignore it,
6110       # but warn the user (except for BASH, which is always set by the calling BASH).
6111       if test "xDIFF" != xBASH; then
6112         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
6113 $as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
6114       fi
6115       # Try to locate tool using the code snippet
6116       for ac_prog in gdiff diff
6117 do
6118   # Extract the first word of "$ac_prog", so it can be a program name with args.
6119 set dummy $ac_prog; ac_word=$2
6120 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6121 $as_echo_n "checking for $ac_word... " >&6; }
6122 if ${ac_cv_path_DIFF+:} false; then :
6123   $as_echo_n "(cached) " >&6
6124 else
6125   case $DIFF in
6126   [\\/]* | ?:[\\/]*)
6127   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6128   ;;
6129   *)
6130   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6131 for as_dir in $PATH
6132 do
6133   IFS=$as_save_IFS
6134   test -z "$as_dir" && as_dir=.
6135     for ac_exec_ext in '' $ac_executable_extensions; do
6136   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6137     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6138     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6139     break 2
6140   fi
6141 done
6142   done
6143 IFS=$as_save_IFS
6144 
6145   ;;
6146 esac
6147 fi
6148 DIFF=$ac_cv_path_DIFF
6149 if test -n "$DIFF"; then
6150   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6151 $as_echo "$DIFF" >&6; }
6152 else
6153   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6154 $as_echo "no" >&6; }
6155 fi
6156 
6157 
6158   test -n "$DIFF" && break
6159 done
6160 
6161     else
6162       # If it succeeded, then it was overridden by the user. We will use it
6163       # for the tool.
6164 
6165       # First remove it from the list of overridden variables, so we can test
6166       # for unknown variables in the end.
6167       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6168 
6169       # Check if the provided tool contains a complete path.
6170       tool_specified="$DIFF"
6171       tool_basename="${tool_specified##*/}"
6172       if test "x$tool_basename" = "x$tool_specified"; then
6173         # A command without a complete path is provided, search $PATH.
6174         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
6175 $as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
6176         # Extract the first word of "$tool_basename", so it can be a program name with args.
6177 set dummy $tool_basename; ac_word=$2
6178 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6179 $as_echo_n "checking for $ac_word... " >&6; }
6180 if ${ac_cv_path_DIFF+:} false; then :
6181   $as_echo_n "(cached) " >&6
6182 else
6183   case $DIFF in
6184   [\\/]* | ?:[\\/]*)
6185   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6186   ;;
6187   *)
6188   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6189 for as_dir in $PATH
6190 do
6191   IFS=$as_save_IFS
6192   test -z "$as_dir" && as_dir=.
6193     for ac_exec_ext in '' $ac_executable_extensions; do
6194   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6195     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6196     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6197     break 2
6198   fi
6199 done
6200   done
6201 IFS=$as_save_IFS
6202 
6203   ;;
6204 esac
6205 fi
6206 DIFF=$ac_cv_path_DIFF
6207 if test -n "$DIFF"; then
6208   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6209 $as_echo "$DIFF" >&6; }
6210 else
6211   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6212 $as_echo "no" >&6; }
6213 fi
6214 
6215 
6216         if test "x$DIFF" = x; then
6217           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6218         fi
6219       else
6220         # Otherwise we believe it is a complete path. Use it as it is.
6221         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
6222 $as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
6223         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
6224 $as_echo_n "checking for DIFF... " >&6; }
6225         if test ! -x "$tool_specified"; then
6226           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6227 $as_echo "not found" >&6; }
6228           as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
6229         fi
6230         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6231 $as_echo "$tool_specified" >&6; }
6232       fi
6233     fi
6234   fi
6235 
6236 
6237 
6238   if test "x$DIFF" = x; then
6239     as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
6240   fi
6241 
6242 
6243 
6244 
6245 
6246   # Publish this variable in the help.
6247 
6248 
6249   if test "x$DIRNAME" = x; then
6250     # The variable is not set by user, try to locate tool using the code snippet
6251     for ac_prog in dirname
6252 do
6253   # Extract the first word of "$ac_prog", so it can be a program name with args.
6254 set dummy $ac_prog; ac_word=$2
6255 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6256 $as_echo_n "checking for $ac_word... " >&6; }
6257 if ${ac_cv_path_DIRNAME+:} false; then :
6258   $as_echo_n "(cached) " >&6
6259 else
6260   case $DIRNAME in
6261   [\\/]* | ?:[\\/]*)
6262   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6263   ;;
6264   *)
6265   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6266 for as_dir in $PATH
6267 do
6268   IFS=$as_save_IFS
6269   test -z "$as_dir" && as_dir=.
6270     for ac_exec_ext in '' $ac_executable_extensions; do
6271   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6272     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6273     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6274     break 2
6275   fi
6276 done
6277   done
6278 IFS=$as_save_IFS
6279 
6280   ;;
6281 esac
6282 fi
6283 DIRNAME=$ac_cv_path_DIRNAME
6284 if test -n "$DIRNAME"; then
6285   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6286 $as_echo "$DIRNAME" >&6; }
6287 else
6288   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6289 $as_echo "no" >&6; }
6290 fi
6291 
6292 
6293   test -n "$DIRNAME" && break
6294 done
6295 
6296   else
6297     # The variable is set, but is it from the command line or the environment?
6298 
6299     # Try to remove the string !DIRNAME! from our list.
6300     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
6301     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6302       # If it failed, the variable was not from the command line. Ignore it,
6303       # but warn the user (except for BASH, which is always set by the calling BASH).
6304       if test "xDIRNAME" != xBASH; then
6305         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
6306 $as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
6307       fi
6308       # Try to locate tool using the code snippet
6309       for ac_prog in dirname
6310 do
6311   # Extract the first word of "$ac_prog", so it can be a program name with args.
6312 set dummy $ac_prog; ac_word=$2
6313 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6314 $as_echo_n "checking for $ac_word... " >&6; }
6315 if ${ac_cv_path_DIRNAME+:} false; then :
6316   $as_echo_n "(cached) " >&6
6317 else
6318   case $DIRNAME in
6319   [\\/]* | ?:[\\/]*)
6320   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6321   ;;
6322   *)
6323   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6324 for as_dir in $PATH
6325 do
6326   IFS=$as_save_IFS
6327   test -z "$as_dir" && as_dir=.
6328     for ac_exec_ext in '' $ac_executable_extensions; do
6329   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6330     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6331     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6332     break 2
6333   fi
6334 done
6335   done
6336 IFS=$as_save_IFS
6337 
6338   ;;
6339 esac
6340 fi
6341 DIRNAME=$ac_cv_path_DIRNAME
6342 if test -n "$DIRNAME"; then
6343   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6344 $as_echo "$DIRNAME" >&6; }
6345 else
6346   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6347 $as_echo "no" >&6; }
6348 fi
6349 
6350 
6351   test -n "$DIRNAME" && break
6352 done
6353 
6354     else
6355       # If it succeeded, then it was overridden by the user. We will use it
6356       # for the tool.
6357 
6358       # First remove it from the list of overridden variables, so we can test
6359       # for unknown variables in the end.
6360       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6361 
6362       # Check if the provided tool contains a complete path.
6363       tool_specified="$DIRNAME"
6364       tool_basename="${tool_specified##*/}"
6365       if test "x$tool_basename" = "x$tool_specified"; then
6366         # A command without a complete path is provided, search $PATH.
6367         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
6368 $as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
6369         # Extract the first word of "$tool_basename", so it can be a program name with args.
6370 set dummy $tool_basename; ac_word=$2
6371 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6372 $as_echo_n "checking for $ac_word... " >&6; }
6373 if ${ac_cv_path_DIRNAME+:} false; then :
6374   $as_echo_n "(cached) " >&6
6375 else
6376   case $DIRNAME in
6377   [\\/]* | ?:[\\/]*)
6378   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6379   ;;
6380   *)
6381   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6382 for as_dir in $PATH
6383 do
6384   IFS=$as_save_IFS
6385   test -z "$as_dir" && as_dir=.
6386     for ac_exec_ext in '' $ac_executable_extensions; do
6387   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6388     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6389     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6390     break 2
6391   fi
6392 done
6393   done
6394 IFS=$as_save_IFS
6395 
6396   ;;
6397 esac
6398 fi
6399 DIRNAME=$ac_cv_path_DIRNAME
6400 if test -n "$DIRNAME"; then
6401   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6402 $as_echo "$DIRNAME" >&6; }
6403 else
6404   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6405 $as_echo "no" >&6; }
6406 fi
6407 
6408 
6409         if test "x$DIRNAME" = x; then
6410           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6411         fi
6412       else
6413         # Otherwise we believe it is a complete path. Use it as it is.
6414         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
6415 $as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
6416         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
6417 $as_echo_n "checking for DIRNAME... " >&6; }
6418         if test ! -x "$tool_specified"; then
6419           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6420 $as_echo "not found" >&6; }
6421           as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
6422         fi
6423         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6424 $as_echo "$tool_specified" >&6; }
6425       fi
6426     fi
6427   fi
6428 
6429 
6430 
6431   if test "x$DIRNAME" = x; then
6432     as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
6433   fi
6434 
6435 
6436 
6437 
6438 
6439   # Publish this variable in the help.
6440 
6441 
6442   if test "x$ECHO" = x; then
6443     # The variable is not set by user, try to locate tool using the code snippet
6444     for ac_prog in echo
6445 do
6446   # Extract the first word of "$ac_prog", so it can be a program name with args.
6447 set dummy $ac_prog; ac_word=$2
6448 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6449 $as_echo_n "checking for $ac_word... " >&6; }
6450 if ${ac_cv_path_ECHO+:} false; then :
6451   $as_echo_n "(cached) " >&6
6452 else
6453   case $ECHO in
6454   [\\/]* | ?:[\\/]*)
6455   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6456   ;;
6457   *)
6458   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6459 for as_dir in $PATH
6460 do
6461   IFS=$as_save_IFS
6462   test -z "$as_dir" && as_dir=.
6463     for ac_exec_ext in '' $ac_executable_extensions; do
6464   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6465     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6466     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6467     break 2
6468   fi
6469 done
6470   done
6471 IFS=$as_save_IFS
6472 
6473   ;;
6474 esac
6475 fi
6476 ECHO=$ac_cv_path_ECHO
6477 if test -n "$ECHO"; then
6478   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6479 $as_echo "$ECHO" >&6; }
6480 else
6481   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6482 $as_echo "no" >&6; }
6483 fi
6484 
6485 
6486   test -n "$ECHO" && break
6487 done
6488 
6489   else
6490     # The variable is set, but is it from the command line or the environment?
6491 
6492     # Try to remove the string !ECHO! from our list.
6493     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
6494     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6495       # If it failed, the variable was not from the command line. Ignore it,
6496       # but warn the user (except for BASH, which is always set by the calling BASH).
6497       if test "xECHO" != xBASH; then
6498         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
6499 $as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
6500       fi
6501       # Try to locate tool using the code snippet
6502       for ac_prog in echo
6503 do
6504   # Extract the first word of "$ac_prog", so it can be a program name with args.
6505 set dummy $ac_prog; ac_word=$2
6506 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6507 $as_echo_n "checking for $ac_word... " >&6; }
6508 if ${ac_cv_path_ECHO+:} false; then :
6509   $as_echo_n "(cached) " >&6
6510 else
6511   case $ECHO in
6512   [\\/]* | ?:[\\/]*)
6513   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6514   ;;
6515   *)
6516   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6517 for as_dir in $PATH
6518 do
6519   IFS=$as_save_IFS
6520   test -z "$as_dir" && as_dir=.
6521     for ac_exec_ext in '' $ac_executable_extensions; do
6522   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6523     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6524     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6525     break 2
6526   fi
6527 done
6528   done
6529 IFS=$as_save_IFS
6530 
6531   ;;
6532 esac
6533 fi
6534 ECHO=$ac_cv_path_ECHO
6535 if test -n "$ECHO"; then
6536   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6537 $as_echo "$ECHO" >&6; }
6538 else
6539   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6540 $as_echo "no" >&6; }
6541 fi
6542 
6543 
6544   test -n "$ECHO" && break
6545 done
6546 
6547     else
6548       # If it succeeded, then it was overridden by the user. We will use it
6549       # for the tool.
6550 
6551       # First remove it from the list of overridden variables, so we can test
6552       # for unknown variables in the end.
6553       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6554 
6555       # Check if the provided tool contains a complete path.
6556       tool_specified="$ECHO"
6557       tool_basename="${tool_specified##*/}"
6558       if test "x$tool_basename" = "x$tool_specified"; then
6559         # A command without a complete path is provided, search $PATH.
6560         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
6561 $as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
6562         # Extract the first word of "$tool_basename", so it can be a program name with args.
6563 set dummy $tool_basename; ac_word=$2
6564 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6565 $as_echo_n "checking for $ac_word... " >&6; }
6566 if ${ac_cv_path_ECHO+:} false; then :
6567   $as_echo_n "(cached) " >&6
6568 else
6569   case $ECHO in
6570   [\\/]* | ?:[\\/]*)
6571   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6572   ;;
6573   *)
6574   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6575 for as_dir in $PATH
6576 do
6577   IFS=$as_save_IFS
6578   test -z "$as_dir" && as_dir=.
6579     for ac_exec_ext in '' $ac_executable_extensions; do
6580   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6581     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6582     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6583     break 2
6584   fi
6585 done
6586   done
6587 IFS=$as_save_IFS
6588 
6589   ;;
6590 esac
6591 fi
6592 ECHO=$ac_cv_path_ECHO
6593 if test -n "$ECHO"; then
6594   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6595 $as_echo "$ECHO" >&6; }
6596 else
6597   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6598 $as_echo "no" >&6; }
6599 fi
6600 
6601 
6602         if test "x$ECHO" = x; then
6603           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6604         fi
6605       else
6606         # Otherwise we believe it is a complete path. Use it as it is.
6607         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
6608 $as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
6609         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
6610 $as_echo_n "checking for ECHO... " >&6; }
6611         if test ! -x "$tool_specified"; then
6612           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6613 $as_echo "not found" >&6; }
6614           as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
6615         fi
6616         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6617 $as_echo "$tool_specified" >&6; }
6618       fi
6619     fi
6620   fi
6621 
6622 
6623 
6624   if test "x$ECHO" = x; then
6625     as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
6626   fi
6627 
6628 
6629 
6630 
6631 
6632   # Publish this variable in the help.
6633 
6634 
6635   if test "x$EXPR" = x; then
6636     # The variable is not set by user, try to locate tool using the code snippet
6637     for ac_prog in expr
6638 do
6639   # Extract the first word of "$ac_prog", so it can be a program name with args.
6640 set dummy $ac_prog; ac_word=$2
6641 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6642 $as_echo_n "checking for $ac_word... " >&6; }
6643 if ${ac_cv_path_EXPR+:} false; then :
6644   $as_echo_n "(cached) " >&6
6645 else
6646   case $EXPR in
6647   [\\/]* | ?:[\\/]*)
6648   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6649   ;;
6650   *)
6651   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6652 for as_dir in $PATH
6653 do
6654   IFS=$as_save_IFS
6655   test -z "$as_dir" && as_dir=.
6656     for ac_exec_ext in '' $ac_executable_extensions; do
6657   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6658     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6659     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6660     break 2
6661   fi
6662 done
6663   done
6664 IFS=$as_save_IFS
6665 
6666   ;;
6667 esac
6668 fi
6669 EXPR=$ac_cv_path_EXPR
6670 if test -n "$EXPR"; then
6671   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6672 $as_echo "$EXPR" >&6; }
6673 else
6674   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6675 $as_echo "no" >&6; }
6676 fi
6677 
6678 
6679   test -n "$EXPR" && break
6680 done
6681 
6682   else
6683     # The variable is set, but is it from the command line or the environment?
6684 
6685     # Try to remove the string !EXPR! from our list.
6686     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
6687     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6688       # If it failed, the variable was not from the command line. Ignore it,
6689       # but warn the user (except for BASH, which is always set by the calling BASH).
6690       if test "xEXPR" != xBASH; then
6691         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
6692 $as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
6693       fi
6694       # Try to locate tool using the code snippet
6695       for ac_prog in expr
6696 do
6697   # Extract the first word of "$ac_prog", so it can be a program name with args.
6698 set dummy $ac_prog; ac_word=$2
6699 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6700 $as_echo_n "checking for $ac_word... " >&6; }
6701 if ${ac_cv_path_EXPR+:} false; then :
6702   $as_echo_n "(cached) " >&6
6703 else
6704   case $EXPR in
6705   [\\/]* | ?:[\\/]*)
6706   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6707   ;;
6708   *)
6709   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6710 for as_dir in $PATH
6711 do
6712   IFS=$as_save_IFS
6713   test -z "$as_dir" && as_dir=.
6714     for ac_exec_ext in '' $ac_executable_extensions; do
6715   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6716     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6717     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6718     break 2
6719   fi
6720 done
6721   done
6722 IFS=$as_save_IFS
6723 
6724   ;;
6725 esac
6726 fi
6727 EXPR=$ac_cv_path_EXPR
6728 if test -n "$EXPR"; then
6729   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6730 $as_echo "$EXPR" >&6; }
6731 else
6732   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6733 $as_echo "no" >&6; }
6734 fi
6735 
6736 
6737   test -n "$EXPR" && break
6738 done
6739 
6740     else
6741       # If it succeeded, then it was overridden by the user. We will use it
6742       # for the tool.
6743 
6744       # First remove it from the list of overridden variables, so we can test
6745       # for unknown variables in the end.
6746       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6747 
6748       # Check if the provided tool contains a complete path.
6749       tool_specified="$EXPR"
6750       tool_basename="${tool_specified##*/}"
6751       if test "x$tool_basename" = "x$tool_specified"; then
6752         # A command without a complete path is provided, search $PATH.
6753         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
6754 $as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
6755         # Extract the first word of "$tool_basename", so it can be a program name with args.
6756 set dummy $tool_basename; ac_word=$2
6757 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6758 $as_echo_n "checking for $ac_word... " >&6; }
6759 if ${ac_cv_path_EXPR+:} false; then :
6760   $as_echo_n "(cached) " >&6
6761 else
6762   case $EXPR in
6763   [\\/]* | ?:[\\/]*)
6764   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6765   ;;
6766   *)
6767   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6768 for as_dir in $PATH
6769 do
6770   IFS=$as_save_IFS
6771   test -z "$as_dir" && as_dir=.
6772     for ac_exec_ext in '' $ac_executable_extensions; do
6773   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6774     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6775     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6776     break 2
6777   fi
6778 done
6779   done
6780 IFS=$as_save_IFS
6781 
6782   ;;
6783 esac
6784 fi
6785 EXPR=$ac_cv_path_EXPR
6786 if test -n "$EXPR"; then
6787   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6788 $as_echo "$EXPR" >&6; }
6789 else
6790   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6791 $as_echo "no" >&6; }
6792 fi
6793 
6794 
6795         if test "x$EXPR" = x; then
6796           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6797         fi
6798       else
6799         # Otherwise we believe it is a complete path. Use it as it is.
6800         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
6801 $as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
6802         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
6803 $as_echo_n "checking for EXPR... " >&6; }
6804         if test ! -x "$tool_specified"; then
6805           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6806 $as_echo "not found" >&6; }
6807           as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
6808         fi
6809         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6810 $as_echo "$tool_specified" >&6; }
6811       fi
6812     fi
6813   fi
6814 
6815 
6816 
6817   if test "x$EXPR" = x; then
6818     as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
6819   fi
6820 
6821 
6822 
6823 
6824 
6825   # Publish this variable in the help.
6826 
6827 
6828   if test "x$FILE" = x; then
6829     # The variable is not set by user, try to locate tool using the code snippet
6830     for ac_prog in file
6831 do
6832   # Extract the first word of "$ac_prog", so it can be a program name with args.
6833 set dummy $ac_prog; ac_word=$2
6834 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6835 $as_echo_n "checking for $ac_word... " >&6; }
6836 if ${ac_cv_path_FILE+:} false; then :
6837   $as_echo_n "(cached) " >&6
6838 else
6839   case $FILE in
6840   [\\/]* | ?:[\\/]*)
6841   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
6842   ;;
6843   *)
6844   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6845 for as_dir in $PATH
6846 do
6847   IFS=$as_save_IFS
6848   test -z "$as_dir" && as_dir=.
6849     for ac_exec_ext in '' $ac_executable_extensions; do
6850   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6851     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
6852     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6853     break 2
6854   fi
6855 done
6856   done
6857 IFS=$as_save_IFS
6858 
6859   ;;
6860 esac
6861 fi
6862 FILE=$ac_cv_path_FILE
6863 if test -n "$FILE"; then
6864   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
6865 $as_echo "$FILE" >&6; }
6866 else
6867   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6868 $as_echo "no" >&6; }
6869 fi
6870 
6871 
6872   test -n "$FILE" && break
6873 done
6874 
6875   else
6876     # The variable is set, but is it from the command line or the environment?
6877 
6878     # Try to remove the string !FILE! from our list.
6879     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
6880     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6881       # If it failed, the variable was not from the command line. Ignore it,
6882       # but warn the user (except for BASH, which is always set by the calling BASH).
6883       if test "xFILE" != xBASH; then
6884         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
6885 $as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
6886       fi
6887       # Try to locate tool using the code snippet
6888       for ac_prog in file
6889 do
6890   # Extract the first word of "$ac_prog", so it can be a program name with args.
6891 set dummy $ac_prog; ac_word=$2
6892 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6893 $as_echo_n "checking for $ac_word... " >&6; }
6894 if ${ac_cv_path_FILE+:} false; then :
6895   $as_echo_n "(cached) " >&6
6896 else
6897   case $FILE in
6898   [\\/]* | ?:[\\/]*)
6899   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
6900   ;;
6901   *)
6902   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6903 for as_dir in $PATH
6904 do
6905   IFS=$as_save_IFS
6906   test -z "$as_dir" && as_dir=.
6907     for ac_exec_ext in '' $ac_executable_extensions; do
6908   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6909     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
6910     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6911     break 2
6912   fi
6913 done
6914   done
6915 IFS=$as_save_IFS
6916 
6917   ;;
6918 esac
6919 fi
6920 FILE=$ac_cv_path_FILE
6921 if test -n "$FILE"; then
6922   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
6923 $as_echo "$FILE" >&6; }
6924 else
6925   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6926 $as_echo "no" >&6; }
6927 fi
6928 
6929 
6930   test -n "$FILE" && break
6931 done
6932 
6933     else
6934       # If it succeeded, then it was overridden by the user. We will use it
6935       # for the tool.
6936 
6937       # First remove it from the list of overridden variables, so we can test
6938       # for unknown variables in the end.
6939       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6940 
6941       # Check if the provided tool contains a complete path.
6942       tool_specified="$FILE"
6943       tool_basename="${tool_specified##*/}"
6944       if test "x$tool_basename" = "x$tool_specified"; then
6945         # A command without a complete path is provided, search $PATH.
6946         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
6947 $as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
6948         # Extract the first word of "$tool_basename", so it can be a program name with args.
6949 set dummy $tool_basename; ac_word=$2
6950 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6951 $as_echo_n "checking for $ac_word... " >&6; }
6952 if ${ac_cv_path_FILE+:} false; then :
6953   $as_echo_n "(cached) " >&6
6954 else
6955   case $FILE in
6956   [\\/]* | ?:[\\/]*)
6957   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
6958   ;;
6959   *)
6960   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6961 for as_dir in $PATH
6962 do
6963   IFS=$as_save_IFS
6964   test -z "$as_dir" && as_dir=.
6965     for ac_exec_ext in '' $ac_executable_extensions; do
6966   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6967     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
6968     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6969     break 2
6970   fi
6971 done
6972   done
6973 IFS=$as_save_IFS
6974 
6975   ;;
6976 esac
6977 fi
6978 FILE=$ac_cv_path_FILE
6979 if test -n "$FILE"; then
6980   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
6981 $as_echo "$FILE" >&6; }
6982 else
6983   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6984 $as_echo "no" >&6; }
6985 fi
6986 
6987 
6988         if test "x$FILE" = x; then
6989           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6990         fi
6991       else
6992         # Otherwise we believe it is a complete path. Use it as it is.
6993         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
6994 $as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
6995         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
6996 $as_echo_n "checking for FILE... " >&6; }
6997         if test ! -x "$tool_specified"; then
6998           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6999 $as_echo "not found" >&6; }
7000           as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
7001         fi
7002         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7003 $as_echo "$tool_specified" >&6; }
7004       fi
7005     fi
7006   fi
7007 
7008 
7009 
7010   if test "x$FILE" = x; then
7011     as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
7012   fi
7013 
7014 
7015 
7016 
7017 
7018   # Publish this variable in the help.
7019 
7020 
7021   if test "x$FIND" = x; then
7022     # The variable is not set by user, try to locate tool using the code snippet
7023     for ac_prog in find
7024 do
7025   # Extract the first word of "$ac_prog", so it can be a program name with args.
7026 set dummy $ac_prog; ac_word=$2
7027 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7028 $as_echo_n "checking for $ac_word... " >&6; }
7029 if ${ac_cv_path_FIND+:} false; then :
7030   $as_echo_n "(cached) " >&6
7031 else
7032   case $FIND in
7033   [\\/]* | ?:[\\/]*)
7034   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7035   ;;
7036   *)
7037   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7038 for as_dir in $PATH
7039 do
7040   IFS=$as_save_IFS
7041   test -z "$as_dir" && as_dir=.
7042     for ac_exec_ext in '' $ac_executable_extensions; do
7043   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7044     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7045     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7046     break 2
7047   fi
7048 done
7049   done
7050 IFS=$as_save_IFS
7051 
7052   ;;
7053 esac
7054 fi
7055 FIND=$ac_cv_path_FIND
7056 if test -n "$FIND"; then
7057   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7058 $as_echo "$FIND" >&6; }
7059 else
7060   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7061 $as_echo "no" >&6; }
7062 fi
7063 
7064 
7065   test -n "$FIND" && break
7066 done
7067 
7068   else
7069     # The variable is set, but is it from the command line or the environment?
7070 
7071     # Try to remove the string !FIND! from our list.
7072     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
7073     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7074       # If it failed, the variable was not from the command line. Ignore it,
7075       # but warn the user (except for BASH, which is always set by the calling BASH).
7076       if test "xFIND" != xBASH; then
7077         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
7078 $as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
7079       fi
7080       # Try to locate tool using the code snippet
7081       for ac_prog in find
7082 do
7083   # Extract the first word of "$ac_prog", so it can be a program name with args.
7084 set dummy $ac_prog; ac_word=$2
7085 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7086 $as_echo_n "checking for $ac_word... " >&6; }
7087 if ${ac_cv_path_FIND+:} false; then :
7088   $as_echo_n "(cached) " >&6
7089 else
7090   case $FIND in
7091   [\\/]* | ?:[\\/]*)
7092   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7093   ;;
7094   *)
7095   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7096 for as_dir in $PATH
7097 do
7098   IFS=$as_save_IFS
7099   test -z "$as_dir" && as_dir=.
7100     for ac_exec_ext in '' $ac_executable_extensions; do
7101   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7102     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7103     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7104     break 2
7105   fi
7106 done
7107   done
7108 IFS=$as_save_IFS
7109 
7110   ;;
7111 esac
7112 fi
7113 FIND=$ac_cv_path_FIND
7114 if test -n "$FIND"; then
7115   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7116 $as_echo "$FIND" >&6; }
7117 else
7118   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7119 $as_echo "no" >&6; }
7120 fi
7121 
7122 
7123   test -n "$FIND" && break
7124 done
7125 
7126     else
7127       # If it succeeded, then it was overridden by the user. We will use it
7128       # for the tool.
7129 
7130       # First remove it from the list of overridden variables, so we can test
7131       # for unknown variables in the end.
7132       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7133 
7134       # Check if the provided tool contains a complete path.
7135       tool_specified="$FIND"
7136       tool_basename="${tool_specified##*/}"
7137       if test "x$tool_basename" = "x$tool_specified"; then
7138         # A command without a complete path is provided, search $PATH.
7139         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
7140 $as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
7141         # Extract the first word of "$tool_basename", so it can be a program name with args.
7142 set dummy $tool_basename; ac_word=$2
7143 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7144 $as_echo_n "checking for $ac_word... " >&6; }
7145 if ${ac_cv_path_FIND+:} false; then :
7146   $as_echo_n "(cached) " >&6
7147 else
7148   case $FIND in
7149   [\\/]* | ?:[\\/]*)
7150   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7151   ;;
7152   *)
7153   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7154 for as_dir in $PATH
7155 do
7156   IFS=$as_save_IFS
7157   test -z "$as_dir" && as_dir=.
7158     for ac_exec_ext in '' $ac_executable_extensions; do
7159   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7160     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7161     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7162     break 2
7163   fi
7164 done
7165   done
7166 IFS=$as_save_IFS
7167 
7168   ;;
7169 esac
7170 fi
7171 FIND=$ac_cv_path_FIND
7172 if test -n "$FIND"; then
7173   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7174 $as_echo "$FIND" >&6; }
7175 else
7176   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7177 $as_echo "no" >&6; }
7178 fi
7179 
7180 
7181         if test "x$FIND" = x; then
7182           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7183         fi
7184       else
7185         # Otherwise we believe it is a complete path. Use it as it is.
7186         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
7187 $as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
7188         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
7189 $as_echo_n "checking for FIND... " >&6; }
7190         if test ! -x "$tool_specified"; then
7191           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7192 $as_echo "not found" >&6; }
7193           as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
7194         fi
7195         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7196 $as_echo "$tool_specified" >&6; }
7197       fi
7198     fi
7199   fi
7200 
7201 
7202 
7203   if test "x$FIND" = x; then
7204     as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
7205   fi
7206 
7207 
7208 
7209 
7210 
7211   # Publish this variable in the help.
7212 
7213 
7214   if test "x$HEAD" = x; then
7215     # The variable is not set by user, try to locate tool using the code snippet
7216     for ac_prog in head
7217 do
7218   # Extract the first word of "$ac_prog", so it can be a program name with args.
7219 set dummy $ac_prog; ac_word=$2
7220 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7221 $as_echo_n "checking for $ac_word... " >&6; }
7222 if ${ac_cv_path_HEAD+:} false; then :
7223   $as_echo_n "(cached) " >&6
7224 else
7225   case $HEAD in
7226   [\\/]* | ?:[\\/]*)
7227   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7228   ;;
7229   *)
7230   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7231 for as_dir in $PATH
7232 do
7233   IFS=$as_save_IFS
7234   test -z "$as_dir" && as_dir=.
7235     for ac_exec_ext in '' $ac_executable_extensions; do
7236   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7237     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7238     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7239     break 2
7240   fi
7241 done
7242   done
7243 IFS=$as_save_IFS
7244 
7245   ;;
7246 esac
7247 fi
7248 HEAD=$ac_cv_path_HEAD
7249 if test -n "$HEAD"; then
7250   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7251 $as_echo "$HEAD" >&6; }
7252 else
7253   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7254 $as_echo "no" >&6; }
7255 fi
7256 
7257 
7258   test -n "$HEAD" && break
7259 done
7260 
7261   else
7262     # The variable is set, but is it from the command line or the environment?
7263 
7264     # Try to remove the string !HEAD! from our list.
7265     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
7266     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7267       # If it failed, the variable was not from the command line. Ignore it,
7268       # but warn the user (except for BASH, which is always set by the calling BASH).
7269       if test "xHEAD" != xBASH; then
7270         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
7271 $as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
7272       fi
7273       # Try to locate tool using the code snippet
7274       for ac_prog in head
7275 do
7276   # Extract the first word of "$ac_prog", so it can be a program name with args.
7277 set dummy $ac_prog; ac_word=$2
7278 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7279 $as_echo_n "checking for $ac_word... " >&6; }
7280 if ${ac_cv_path_HEAD+:} false; then :
7281   $as_echo_n "(cached) " >&6
7282 else
7283   case $HEAD in
7284   [\\/]* | ?:[\\/]*)
7285   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7286   ;;
7287   *)
7288   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7289 for as_dir in $PATH
7290 do
7291   IFS=$as_save_IFS
7292   test -z "$as_dir" && as_dir=.
7293     for ac_exec_ext in '' $ac_executable_extensions; do
7294   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7295     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7296     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7297     break 2
7298   fi
7299 done
7300   done
7301 IFS=$as_save_IFS
7302 
7303   ;;
7304 esac
7305 fi
7306 HEAD=$ac_cv_path_HEAD
7307 if test -n "$HEAD"; then
7308   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7309 $as_echo "$HEAD" >&6; }
7310 else
7311   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7312 $as_echo "no" >&6; }
7313 fi
7314 
7315 
7316   test -n "$HEAD" && break
7317 done
7318 
7319     else
7320       # If it succeeded, then it was overridden by the user. We will use it
7321       # for the tool.
7322 
7323       # First remove it from the list of overridden variables, so we can test
7324       # for unknown variables in the end.
7325       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7326 
7327       # Check if the provided tool contains a complete path.
7328       tool_specified="$HEAD"
7329       tool_basename="${tool_specified##*/}"
7330       if test "x$tool_basename" = "x$tool_specified"; then
7331         # A command without a complete path is provided, search $PATH.
7332         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
7333 $as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
7334         # Extract the first word of "$tool_basename", so it can be a program name with args.
7335 set dummy $tool_basename; ac_word=$2
7336 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7337 $as_echo_n "checking for $ac_word... " >&6; }
7338 if ${ac_cv_path_HEAD+:} false; then :
7339   $as_echo_n "(cached) " >&6
7340 else
7341   case $HEAD in
7342   [\\/]* | ?:[\\/]*)
7343   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7344   ;;
7345   *)
7346   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7347 for as_dir in $PATH
7348 do
7349   IFS=$as_save_IFS
7350   test -z "$as_dir" && as_dir=.
7351     for ac_exec_ext in '' $ac_executable_extensions; do
7352   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7353     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7354     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7355     break 2
7356   fi
7357 done
7358   done
7359 IFS=$as_save_IFS
7360 
7361   ;;
7362 esac
7363 fi
7364 HEAD=$ac_cv_path_HEAD
7365 if test -n "$HEAD"; then
7366   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7367 $as_echo "$HEAD" >&6; }
7368 else
7369   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7370 $as_echo "no" >&6; }
7371 fi
7372 
7373 
7374         if test "x$HEAD" = x; then
7375           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7376         fi
7377       else
7378         # Otherwise we believe it is a complete path. Use it as it is.
7379         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
7380 $as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
7381         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
7382 $as_echo_n "checking for HEAD... " >&6; }
7383         if test ! -x "$tool_specified"; then
7384           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7385 $as_echo "not found" >&6; }
7386           as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
7387         fi
7388         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7389 $as_echo "$tool_specified" >&6; }
7390       fi
7391     fi
7392   fi
7393 
7394 
7395 
7396   if test "x$HEAD" = x; then
7397     as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
7398   fi
7399 
7400 
7401 
7402 
7403 
7404   # Publish this variable in the help.
7405 
7406 
7407   if test "x$LN" = x; then
7408     # The variable is not set by user, try to locate tool using the code snippet
7409     for ac_prog in ln
7410 do
7411   # Extract the first word of "$ac_prog", so it can be a program name with args.
7412 set dummy $ac_prog; ac_word=$2
7413 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7414 $as_echo_n "checking for $ac_word... " >&6; }
7415 if ${ac_cv_path_LN+:} false; then :
7416   $as_echo_n "(cached) " >&6
7417 else
7418   case $LN in
7419   [\\/]* | ?:[\\/]*)
7420   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7421   ;;
7422   *)
7423   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7424 for as_dir in $PATH
7425 do
7426   IFS=$as_save_IFS
7427   test -z "$as_dir" && as_dir=.
7428     for ac_exec_ext in '' $ac_executable_extensions; do
7429   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7430     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7431     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7432     break 2
7433   fi
7434 done
7435   done
7436 IFS=$as_save_IFS
7437 
7438   ;;
7439 esac
7440 fi
7441 LN=$ac_cv_path_LN
7442 if test -n "$LN"; then
7443   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7444 $as_echo "$LN" >&6; }
7445 else
7446   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7447 $as_echo "no" >&6; }
7448 fi
7449 
7450 
7451   test -n "$LN" && break
7452 done
7453 
7454   else
7455     # The variable is set, but is it from the command line or the environment?
7456 
7457     # Try to remove the string !LN! from our list.
7458     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
7459     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7460       # If it failed, the variable was not from the command line. Ignore it,
7461       # but warn the user (except for BASH, which is always set by the calling BASH).
7462       if test "xLN" != xBASH; then
7463         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
7464 $as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
7465       fi
7466       # Try to locate tool using the code snippet
7467       for ac_prog in ln
7468 do
7469   # Extract the first word of "$ac_prog", so it can be a program name with args.
7470 set dummy $ac_prog; ac_word=$2
7471 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7472 $as_echo_n "checking for $ac_word... " >&6; }
7473 if ${ac_cv_path_LN+:} false; then :
7474   $as_echo_n "(cached) " >&6
7475 else
7476   case $LN in
7477   [\\/]* | ?:[\\/]*)
7478   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7479   ;;
7480   *)
7481   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7482 for as_dir in $PATH
7483 do
7484   IFS=$as_save_IFS
7485   test -z "$as_dir" && as_dir=.
7486     for ac_exec_ext in '' $ac_executable_extensions; do
7487   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7488     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7489     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7490     break 2
7491   fi
7492 done
7493   done
7494 IFS=$as_save_IFS
7495 
7496   ;;
7497 esac
7498 fi
7499 LN=$ac_cv_path_LN
7500 if test -n "$LN"; then
7501   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7502 $as_echo "$LN" >&6; }
7503 else
7504   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7505 $as_echo "no" >&6; }
7506 fi
7507 
7508 
7509   test -n "$LN" && break
7510 done
7511 
7512     else
7513       # If it succeeded, then it was overridden by the user. We will use it
7514       # for the tool.
7515 
7516       # First remove it from the list of overridden variables, so we can test
7517       # for unknown variables in the end.
7518       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7519 
7520       # Check if the provided tool contains a complete path.
7521       tool_specified="$LN"
7522       tool_basename="${tool_specified##*/}"
7523       if test "x$tool_basename" = "x$tool_specified"; then
7524         # A command without a complete path is provided, search $PATH.
7525         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
7526 $as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
7527         # Extract the first word of "$tool_basename", so it can be a program name with args.
7528 set dummy $tool_basename; ac_word=$2
7529 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7530 $as_echo_n "checking for $ac_word... " >&6; }
7531 if ${ac_cv_path_LN+:} false; then :
7532   $as_echo_n "(cached) " >&6
7533 else
7534   case $LN in
7535   [\\/]* | ?:[\\/]*)
7536   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7537   ;;
7538   *)
7539   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7540 for as_dir in $PATH
7541 do
7542   IFS=$as_save_IFS
7543   test -z "$as_dir" && as_dir=.
7544     for ac_exec_ext in '' $ac_executable_extensions; do
7545   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7546     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7547     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7548     break 2
7549   fi
7550 done
7551   done
7552 IFS=$as_save_IFS
7553 
7554   ;;
7555 esac
7556 fi
7557 LN=$ac_cv_path_LN
7558 if test -n "$LN"; then
7559   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7560 $as_echo "$LN" >&6; }
7561 else
7562   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7563 $as_echo "no" >&6; }
7564 fi
7565 
7566 
7567         if test "x$LN" = x; then
7568           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7569         fi
7570       else
7571         # Otherwise we believe it is a complete path. Use it as it is.
7572         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
7573 $as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
7574         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
7575 $as_echo_n "checking for LN... " >&6; }
7576         if test ! -x "$tool_specified"; then
7577           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7578 $as_echo "not found" >&6; }
7579           as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
7580         fi
7581         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7582 $as_echo "$tool_specified" >&6; }
7583       fi
7584     fi
7585   fi
7586 
7587 
7588 
7589   if test "x$LN" = x; then
7590     as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
7591   fi
7592 
7593 
7594 
7595 
7596 
7597   # Publish this variable in the help.
7598 
7599 
7600   if test "x$LS" = x; then
7601     # The variable is not set by user, try to locate tool using the code snippet
7602     for ac_prog in ls
7603 do
7604   # Extract the first word of "$ac_prog", so it can be a program name with args.
7605 set dummy $ac_prog; ac_word=$2
7606 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7607 $as_echo_n "checking for $ac_word... " >&6; }
7608 if ${ac_cv_path_LS+:} false; then :
7609   $as_echo_n "(cached) " >&6
7610 else
7611   case $LS in
7612   [\\/]* | ?:[\\/]*)
7613   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7614   ;;
7615   *)
7616   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7617 for as_dir in $PATH
7618 do
7619   IFS=$as_save_IFS
7620   test -z "$as_dir" && as_dir=.
7621     for ac_exec_ext in '' $ac_executable_extensions; do
7622   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7623     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7624     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7625     break 2
7626   fi
7627 done
7628   done
7629 IFS=$as_save_IFS
7630 
7631   ;;
7632 esac
7633 fi
7634 LS=$ac_cv_path_LS
7635 if test -n "$LS"; then
7636   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7637 $as_echo "$LS" >&6; }
7638 else
7639   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7640 $as_echo "no" >&6; }
7641 fi
7642 
7643 
7644   test -n "$LS" && break
7645 done
7646 
7647   else
7648     # The variable is set, but is it from the command line or the environment?
7649 
7650     # Try to remove the string !LS! from our list.
7651     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
7652     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7653       # If it failed, the variable was not from the command line. Ignore it,
7654       # but warn the user (except for BASH, which is always set by the calling BASH).
7655       if test "xLS" != xBASH; then
7656         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
7657 $as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
7658       fi
7659       # Try to locate tool using the code snippet
7660       for ac_prog in ls
7661 do
7662   # Extract the first word of "$ac_prog", so it can be a program name with args.
7663 set dummy $ac_prog; ac_word=$2
7664 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7665 $as_echo_n "checking for $ac_word... " >&6; }
7666 if ${ac_cv_path_LS+:} false; then :
7667   $as_echo_n "(cached) " >&6
7668 else
7669   case $LS in
7670   [\\/]* | ?:[\\/]*)
7671   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7672   ;;
7673   *)
7674   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7675 for as_dir in $PATH
7676 do
7677   IFS=$as_save_IFS
7678   test -z "$as_dir" && as_dir=.
7679     for ac_exec_ext in '' $ac_executable_extensions; do
7680   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7681     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7682     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7683     break 2
7684   fi
7685 done
7686   done
7687 IFS=$as_save_IFS
7688 
7689   ;;
7690 esac
7691 fi
7692 LS=$ac_cv_path_LS
7693 if test -n "$LS"; then
7694   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7695 $as_echo "$LS" >&6; }
7696 else
7697   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7698 $as_echo "no" >&6; }
7699 fi
7700 
7701 
7702   test -n "$LS" && break
7703 done
7704 
7705     else
7706       # If it succeeded, then it was overridden by the user. We will use it
7707       # for the tool.
7708 
7709       # First remove it from the list of overridden variables, so we can test
7710       # for unknown variables in the end.
7711       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7712 
7713       # Check if the provided tool contains a complete path.
7714       tool_specified="$LS"
7715       tool_basename="${tool_specified##*/}"
7716       if test "x$tool_basename" = "x$tool_specified"; then
7717         # A command without a complete path is provided, search $PATH.
7718         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
7719 $as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
7720         # Extract the first word of "$tool_basename", so it can be a program name with args.
7721 set dummy $tool_basename; ac_word=$2
7722 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7723 $as_echo_n "checking for $ac_word... " >&6; }
7724 if ${ac_cv_path_LS+:} false; then :
7725   $as_echo_n "(cached) " >&6
7726 else
7727   case $LS in
7728   [\\/]* | ?:[\\/]*)
7729   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7730   ;;
7731   *)
7732   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7733 for as_dir in $PATH
7734 do
7735   IFS=$as_save_IFS
7736   test -z "$as_dir" && as_dir=.
7737     for ac_exec_ext in '' $ac_executable_extensions; do
7738   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7739     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7740     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7741     break 2
7742   fi
7743 done
7744   done
7745 IFS=$as_save_IFS
7746 
7747   ;;
7748 esac
7749 fi
7750 LS=$ac_cv_path_LS
7751 if test -n "$LS"; then
7752   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7753 $as_echo "$LS" >&6; }
7754 else
7755   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7756 $as_echo "no" >&6; }
7757 fi
7758 
7759 
7760         if test "x$LS" = x; then
7761           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7762         fi
7763       else
7764         # Otherwise we believe it is a complete path. Use it as it is.
7765         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
7766 $as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
7767         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
7768 $as_echo_n "checking for LS... " >&6; }
7769         if test ! -x "$tool_specified"; then
7770           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7771 $as_echo "not found" >&6; }
7772           as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
7773         fi
7774         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7775 $as_echo "$tool_specified" >&6; }
7776       fi
7777     fi
7778   fi
7779 
7780 
7781 
7782   if test "x$LS" = x; then
7783     as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
7784   fi
7785 
7786 
7787 
7788 
7789 
7790   # Publish this variable in the help.
7791 
7792 
7793   if test "x$MKDIR" = x; then
7794     # The variable is not set by user, try to locate tool using the code snippet
7795     for ac_prog in mkdir
7796 do
7797   # Extract the first word of "$ac_prog", so it can be a program name with args.
7798 set dummy $ac_prog; ac_word=$2
7799 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7800 $as_echo_n "checking for $ac_word... " >&6; }
7801 if ${ac_cv_path_MKDIR+:} false; then :
7802   $as_echo_n "(cached) " >&6
7803 else
7804   case $MKDIR in
7805   [\\/]* | ?:[\\/]*)
7806   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7807   ;;
7808   *)
7809   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7810 for as_dir in $PATH
7811 do
7812   IFS=$as_save_IFS
7813   test -z "$as_dir" && as_dir=.
7814     for ac_exec_ext in '' $ac_executable_extensions; do
7815   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7816     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7817     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7818     break 2
7819   fi
7820 done
7821   done
7822 IFS=$as_save_IFS
7823 
7824   ;;
7825 esac
7826 fi
7827 MKDIR=$ac_cv_path_MKDIR
7828 if test -n "$MKDIR"; then
7829   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
7830 $as_echo "$MKDIR" >&6; }
7831 else
7832   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7833 $as_echo "no" >&6; }
7834 fi
7835 
7836 
7837   test -n "$MKDIR" && break
7838 done
7839 
7840   else
7841     # The variable is set, but is it from the command line or the environment?
7842 
7843     # Try to remove the string !MKDIR! from our list.
7844     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
7845     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7846       # If it failed, the variable was not from the command line. Ignore it,
7847       # but warn the user (except for BASH, which is always set by the calling BASH).
7848       if test "xMKDIR" != xBASH; then
7849         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
7850 $as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
7851       fi
7852       # Try to locate tool using the code snippet
7853       for ac_prog in mkdir
7854 do
7855   # Extract the first word of "$ac_prog", so it can be a program name with args.
7856 set dummy $ac_prog; ac_word=$2
7857 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7858 $as_echo_n "checking for $ac_word... " >&6; }
7859 if ${ac_cv_path_MKDIR+:} false; then :
7860   $as_echo_n "(cached) " >&6
7861 else
7862   case $MKDIR in
7863   [\\/]* | ?:[\\/]*)
7864   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7865   ;;
7866   *)
7867   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7868 for as_dir in $PATH
7869 do
7870   IFS=$as_save_IFS
7871   test -z "$as_dir" && as_dir=.
7872     for ac_exec_ext in '' $ac_executable_extensions; do
7873   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7874     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7875     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7876     break 2
7877   fi
7878 done
7879   done
7880 IFS=$as_save_IFS
7881 
7882   ;;
7883 esac
7884 fi
7885 MKDIR=$ac_cv_path_MKDIR
7886 if test -n "$MKDIR"; then
7887   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
7888 $as_echo "$MKDIR" >&6; }
7889 else
7890   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7891 $as_echo "no" >&6; }
7892 fi
7893 
7894 
7895   test -n "$MKDIR" && break
7896 done
7897 
7898     else
7899       # If it succeeded, then it was overridden by the user. We will use it
7900       # for the tool.
7901 
7902       # First remove it from the list of overridden variables, so we can test
7903       # for unknown variables in the end.
7904       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7905 
7906       # Check if the provided tool contains a complete path.
7907       tool_specified="$MKDIR"
7908       tool_basename="${tool_specified##*/}"
7909       if test "x$tool_basename" = "x$tool_specified"; then
7910         # A command without a complete path is provided, search $PATH.
7911         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
7912 $as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
7913         # Extract the first word of "$tool_basename", so it can be a program name with args.
7914 set dummy $tool_basename; ac_word=$2
7915 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7916 $as_echo_n "checking for $ac_word... " >&6; }
7917 if ${ac_cv_path_MKDIR+:} false; then :
7918   $as_echo_n "(cached) " >&6
7919 else
7920   case $MKDIR in
7921   [\\/]* | ?:[\\/]*)
7922   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7923   ;;
7924   *)
7925   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7926 for as_dir in $PATH
7927 do
7928   IFS=$as_save_IFS
7929   test -z "$as_dir" && as_dir=.
7930     for ac_exec_ext in '' $ac_executable_extensions; do
7931   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7932     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7933     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7934     break 2
7935   fi
7936 done
7937   done
7938 IFS=$as_save_IFS
7939 
7940   ;;
7941 esac
7942 fi
7943 MKDIR=$ac_cv_path_MKDIR
7944 if test -n "$MKDIR"; then
7945   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
7946 $as_echo "$MKDIR" >&6; }
7947 else
7948   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7949 $as_echo "no" >&6; }
7950 fi
7951 
7952 
7953         if test "x$MKDIR" = x; then
7954           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7955         fi
7956       else
7957         # Otherwise we believe it is a complete path. Use it as it is.
7958         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
7959 $as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
7960         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
7961 $as_echo_n "checking for MKDIR... " >&6; }
7962         if test ! -x "$tool_specified"; then
7963           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7964 $as_echo "not found" >&6; }
7965           as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
7966         fi
7967         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7968 $as_echo "$tool_specified" >&6; }
7969       fi
7970     fi
7971   fi
7972 
7973 
7974 
7975   if test "x$MKDIR" = x; then
7976     as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
7977   fi
7978 
7979 
7980 
7981 
7982 
7983   # Publish this variable in the help.
7984 
7985 
7986   if test "x$MKTEMP" = x; then
7987     # The variable is not set by user, try to locate tool using the code snippet
7988     for ac_prog in mktemp
7989 do
7990   # Extract the first word of "$ac_prog", so it can be a program name with args.
7991 set dummy $ac_prog; ac_word=$2
7992 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7993 $as_echo_n "checking for $ac_word... " >&6; }
7994 if ${ac_cv_path_MKTEMP+:} false; then :
7995   $as_echo_n "(cached) " >&6
7996 else
7997   case $MKTEMP in
7998   [\\/]* | ?:[\\/]*)
7999   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8000   ;;
8001   *)
8002   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8003 for as_dir in $PATH
8004 do
8005   IFS=$as_save_IFS
8006   test -z "$as_dir" && as_dir=.
8007     for ac_exec_ext in '' $ac_executable_extensions; do
8008   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8009     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8010     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8011     break 2
8012   fi
8013 done
8014   done
8015 IFS=$as_save_IFS
8016 
8017   ;;
8018 esac
8019 fi
8020 MKTEMP=$ac_cv_path_MKTEMP
8021 if test -n "$MKTEMP"; then
8022   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8023 $as_echo "$MKTEMP" >&6; }
8024 else
8025   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8026 $as_echo "no" >&6; }
8027 fi
8028 
8029 
8030   test -n "$MKTEMP" && break
8031 done
8032 
8033   else
8034     # The variable is set, but is it from the command line or the environment?
8035 
8036     # Try to remove the string !MKTEMP! from our list.
8037     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
8038     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8039       # If it failed, the variable was not from the command line. Ignore it,
8040       # but warn the user (except for BASH, which is always set by the calling BASH).
8041       if test "xMKTEMP" != xBASH; then
8042         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
8043 $as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
8044       fi
8045       # Try to locate tool using the code snippet
8046       for ac_prog in mktemp
8047 do
8048   # Extract the first word of "$ac_prog", so it can be a program name with args.
8049 set dummy $ac_prog; ac_word=$2
8050 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8051 $as_echo_n "checking for $ac_word... " >&6; }
8052 if ${ac_cv_path_MKTEMP+:} false; then :
8053   $as_echo_n "(cached) " >&6
8054 else
8055   case $MKTEMP in
8056   [\\/]* | ?:[\\/]*)
8057   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8058   ;;
8059   *)
8060   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8061 for as_dir in $PATH
8062 do
8063   IFS=$as_save_IFS
8064   test -z "$as_dir" && as_dir=.
8065     for ac_exec_ext in '' $ac_executable_extensions; do
8066   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8067     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8068     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8069     break 2
8070   fi
8071 done
8072   done
8073 IFS=$as_save_IFS
8074 
8075   ;;
8076 esac
8077 fi
8078 MKTEMP=$ac_cv_path_MKTEMP
8079 if test -n "$MKTEMP"; then
8080   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8081 $as_echo "$MKTEMP" >&6; }
8082 else
8083   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8084 $as_echo "no" >&6; }
8085 fi
8086 
8087 
8088   test -n "$MKTEMP" && break
8089 done
8090 
8091     else
8092       # If it succeeded, then it was overridden by the user. We will use it
8093       # for the tool.
8094 
8095       # First remove it from the list of overridden variables, so we can test
8096       # for unknown variables in the end.
8097       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8098 
8099       # Check if the provided tool contains a complete path.
8100       tool_specified="$MKTEMP"
8101       tool_basename="${tool_specified##*/}"
8102       if test "x$tool_basename" = "x$tool_specified"; then
8103         # A command without a complete path is provided, search $PATH.
8104         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
8105 $as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
8106         # Extract the first word of "$tool_basename", so it can be a program name with args.
8107 set dummy $tool_basename; ac_word=$2
8108 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8109 $as_echo_n "checking for $ac_word... " >&6; }
8110 if ${ac_cv_path_MKTEMP+:} false; then :
8111   $as_echo_n "(cached) " >&6
8112 else
8113   case $MKTEMP in
8114   [\\/]* | ?:[\\/]*)
8115   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8116   ;;
8117   *)
8118   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8119 for as_dir in $PATH
8120 do
8121   IFS=$as_save_IFS
8122   test -z "$as_dir" && as_dir=.
8123     for ac_exec_ext in '' $ac_executable_extensions; do
8124   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8125     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8126     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8127     break 2
8128   fi
8129 done
8130   done
8131 IFS=$as_save_IFS
8132 
8133   ;;
8134 esac
8135 fi
8136 MKTEMP=$ac_cv_path_MKTEMP
8137 if test -n "$MKTEMP"; then
8138   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8139 $as_echo "$MKTEMP" >&6; }
8140 else
8141   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8142 $as_echo "no" >&6; }
8143 fi
8144 
8145 
8146         if test "x$MKTEMP" = x; then
8147           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8148         fi
8149       else
8150         # Otherwise we believe it is a complete path. Use it as it is.
8151         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
8152 $as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
8153         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
8154 $as_echo_n "checking for MKTEMP... " >&6; }
8155         if test ! -x "$tool_specified"; then
8156           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8157 $as_echo "not found" >&6; }
8158           as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
8159         fi
8160         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8161 $as_echo "$tool_specified" >&6; }
8162       fi
8163     fi
8164   fi
8165 
8166 
8167 
8168   if test "x$MKTEMP" = x; then
8169     as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
8170   fi
8171 
8172 
8173 
8174 
8175 
8176   # Publish this variable in the help.
8177 
8178 
8179   if test "x$MV" = x; then
8180     # The variable is not set by user, try to locate tool using the code snippet
8181     for ac_prog in mv
8182 do
8183   # Extract the first word of "$ac_prog", so it can be a program name with args.
8184 set dummy $ac_prog; ac_word=$2
8185 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8186 $as_echo_n "checking for $ac_word... " >&6; }
8187 if ${ac_cv_path_MV+:} false; then :
8188   $as_echo_n "(cached) " >&6
8189 else
8190   case $MV in
8191   [\\/]* | ?:[\\/]*)
8192   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8193   ;;
8194   *)
8195   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8196 for as_dir in $PATH
8197 do
8198   IFS=$as_save_IFS
8199   test -z "$as_dir" && as_dir=.
8200     for ac_exec_ext in '' $ac_executable_extensions; do
8201   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8202     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8203     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8204     break 2
8205   fi
8206 done
8207   done
8208 IFS=$as_save_IFS
8209 
8210   ;;
8211 esac
8212 fi
8213 MV=$ac_cv_path_MV
8214 if test -n "$MV"; then
8215   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8216 $as_echo "$MV" >&6; }
8217 else
8218   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8219 $as_echo "no" >&6; }
8220 fi
8221 
8222 
8223   test -n "$MV" && break
8224 done
8225 
8226   else
8227     # The variable is set, but is it from the command line or the environment?
8228 
8229     # Try to remove the string !MV! from our list.
8230     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
8231     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8232       # If it failed, the variable was not from the command line. Ignore it,
8233       # but warn the user (except for BASH, which is always set by the calling BASH).
8234       if test "xMV" != xBASH; then
8235         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
8236 $as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
8237       fi
8238       # Try to locate tool using the code snippet
8239       for ac_prog in mv
8240 do
8241   # Extract the first word of "$ac_prog", so it can be a program name with args.
8242 set dummy $ac_prog; ac_word=$2
8243 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8244 $as_echo_n "checking for $ac_word... " >&6; }
8245 if ${ac_cv_path_MV+:} false; then :
8246   $as_echo_n "(cached) " >&6
8247 else
8248   case $MV in
8249   [\\/]* | ?:[\\/]*)
8250   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8251   ;;
8252   *)
8253   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8254 for as_dir in $PATH
8255 do
8256   IFS=$as_save_IFS
8257   test -z "$as_dir" && as_dir=.
8258     for ac_exec_ext in '' $ac_executable_extensions; do
8259   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8260     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8261     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8262     break 2
8263   fi
8264 done
8265   done
8266 IFS=$as_save_IFS
8267 
8268   ;;
8269 esac
8270 fi
8271 MV=$ac_cv_path_MV
8272 if test -n "$MV"; then
8273   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8274 $as_echo "$MV" >&6; }
8275 else
8276   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8277 $as_echo "no" >&6; }
8278 fi
8279 
8280 
8281   test -n "$MV" && break
8282 done
8283 
8284     else
8285       # If it succeeded, then it was overridden by the user. We will use it
8286       # for the tool.
8287 
8288       # First remove it from the list of overridden variables, so we can test
8289       # for unknown variables in the end.
8290       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8291 
8292       # Check if the provided tool contains a complete path.
8293       tool_specified="$MV"
8294       tool_basename="${tool_specified##*/}"
8295       if test "x$tool_basename" = "x$tool_specified"; then
8296         # A command without a complete path is provided, search $PATH.
8297         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
8298 $as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
8299         # Extract the first word of "$tool_basename", so it can be a program name with args.
8300 set dummy $tool_basename; ac_word=$2
8301 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8302 $as_echo_n "checking for $ac_word... " >&6; }
8303 if ${ac_cv_path_MV+:} false; then :
8304   $as_echo_n "(cached) " >&6
8305 else
8306   case $MV in
8307   [\\/]* | ?:[\\/]*)
8308   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8309   ;;
8310   *)
8311   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8312 for as_dir in $PATH
8313 do
8314   IFS=$as_save_IFS
8315   test -z "$as_dir" && as_dir=.
8316     for ac_exec_ext in '' $ac_executable_extensions; do
8317   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8318     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8319     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8320     break 2
8321   fi
8322 done
8323   done
8324 IFS=$as_save_IFS
8325 
8326   ;;
8327 esac
8328 fi
8329 MV=$ac_cv_path_MV
8330 if test -n "$MV"; then
8331   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8332 $as_echo "$MV" >&6; }
8333 else
8334   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8335 $as_echo "no" >&6; }
8336 fi
8337 
8338 
8339         if test "x$MV" = x; then
8340           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8341         fi
8342       else
8343         # Otherwise we believe it is a complete path. Use it as it is.
8344         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
8345 $as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
8346         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
8347 $as_echo_n "checking for MV... " >&6; }
8348         if test ! -x "$tool_specified"; then
8349           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8350 $as_echo "not found" >&6; }
8351           as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
8352         fi
8353         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8354 $as_echo "$tool_specified" >&6; }
8355       fi
8356     fi
8357   fi
8358 
8359 
8360 
8361   if test "x$MV" = x; then
8362     as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
8363   fi
8364 
8365 
8366 
8367 
8368 
8369   # Publish this variable in the help.
8370 
8371 
8372   if test "x$NAWK" = x; then
8373     # The variable is not set by user, try to locate tool using the code snippet
8374     for ac_prog in nawk gawk awk
8375 do
8376   # Extract the first word of "$ac_prog", so it can be a program name with args.
8377 set dummy $ac_prog; ac_word=$2
8378 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8379 $as_echo_n "checking for $ac_word... " >&6; }
8380 if ${ac_cv_path_NAWK+:} false; then :
8381   $as_echo_n "(cached) " >&6
8382 else
8383   case $NAWK in
8384   [\\/]* | ?:[\\/]*)
8385   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8386   ;;
8387   *)
8388   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8389 for as_dir in $PATH
8390 do
8391   IFS=$as_save_IFS
8392   test -z "$as_dir" && as_dir=.
8393     for ac_exec_ext in '' $ac_executable_extensions; do
8394   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8395     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8396     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8397     break 2
8398   fi
8399 done
8400   done
8401 IFS=$as_save_IFS
8402 
8403   ;;
8404 esac
8405 fi
8406 NAWK=$ac_cv_path_NAWK
8407 if test -n "$NAWK"; then
8408   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8409 $as_echo "$NAWK" >&6; }
8410 else
8411   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8412 $as_echo "no" >&6; }
8413 fi
8414 
8415 
8416   test -n "$NAWK" && break
8417 done
8418 
8419   else
8420     # The variable is set, but is it from the command line or the environment?
8421 
8422     # Try to remove the string !NAWK! from our list.
8423     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
8424     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8425       # If it failed, the variable was not from the command line. Ignore it,
8426       # but warn the user (except for BASH, which is always set by the calling BASH).
8427       if test "xNAWK" != xBASH; then
8428         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
8429 $as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
8430       fi
8431       # Try to locate tool using the code snippet
8432       for ac_prog in nawk gawk awk
8433 do
8434   # Extract the first word of "$ac_prog", so it can be a program name with args.
8435 set dummy $ac_prog; ac_word=$2
8436 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8437 $as_echo_n "checking for $ac_word... " >&6; }
8438 if ${ac_cv_path_NAWK+:} false; then :
8439   $as_echo_n "(cached) " >&6
8440 else
8441   case $NAWK in
8442   [\\/]* | ?:[\\/]*)
8443   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8444   ;;
8445   *)
8446   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8447 for as_dir in $PATH
8448 do
8449   IFS=$as_save_IFS
8450   test -z "$as_dir" && as_dir=.
8451     for ac_exec_ext in '' $ac_executable_extensions; do
8452   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8453     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8454     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8455     break 2
8456   fi
8457 done
8458   done
8459 IFS=$as_save_IFS
8460 
8461   ;;
8462 esac
8463 fi
8464 NAWK=$ac_cv_path_NAWK
8465 if test -n "$NAWK"; then
8466   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8467 $as_echo "$NAWK" >&6; }
8468 else
8469   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8470 $as_echo "no" >&6; }
8471 fi
8472 
8473 
8474   test -n "$NAWK" && break
8475 done
8476 
8477     else
8478       # If it succeeded, then it was overridden by the user. We will use it
8479       # for the tool.
8480 
8481       # First remove it from the list of overridden variables, so we can test
8482       # for unknown variables in the end.
8483       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8484 
8485       # Check if the provided tool contains a complete path.
8486       tool_specified="$NAWK"
8487       tool_basename="${tool_specified##*/}"
8488       if test "x$tool_basename" = "x$tool_specified"; then
8489         # A command without a complete path is provided, search $PATH.
8490         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
8491 $as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
8492         # Extract the first word of "$tool_basename", so it can be a program name with args.
8493 set dummy $tool_basename; ac_word=$2
8494 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8495 $as_echo_n "checking for $ac_word... " >&6; }
8496 if ${ac_cv_path_NAWK+:} false; then :
8497   $as_echo_n "(cached) " >&6
8498 else
8499   case $NAWK in
8500   [\\/]* | ?:[\\/]*)
8501   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8502   ;;
8503   *)
8504   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8505 for as_dir in $PATH
8506 do
8507   IFS=$as_save_IFS
8508   test -z "$as_dir" && as_dir=.
8509     for ac_exec_ext in '' $ac_executable_extensions; do
8510   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8511     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8512     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8513     break 2
8514   fi
8515 done
8516   done
8517 IFS=$as_save_IFS
8518 
8519   ;;
8520 esac
8521 fi
8522 NAWK=$ac_cv_path_NAWK
8523 if test -n "$NAWK"; then
8524   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8525 $as_echo "$NAWK" >&6; }
8526 else
8527   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8528 $as_echo "no" >&6; }
8529 fi
8530 
8531 
8532         if test "x$NAWK" = x; then
8533           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8534         fi
8535       else
8536         # Otherwise we believe it is a complete path. Use it as it is.
8537         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
8538 $as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
8539         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
8540 $as_echo_n "checking for NAWK... " >&6; }
8541         if test ! -x "$tool_specified"; then
8542           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8543 $as_echo "not found" >&6; }
8544           as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
8545         fi
8546         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8547 $as_echo "$tool_specified" >&6; }
8548       fi
8549     fi
8550   fi
8551 
8552 
8553 
8554   if test "x$NAWK" = x; then
8555     as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
8556   fi
8557 
8558 
8559 
8560 
8561 
8562   # Publish this variable in the help.
8563 
8564 
8565   if test "x$PRINTF" = x; then
8566     # The variable is not set by user, try to locate tool using the code snippet
8567     for ac_prog in printf
8568 do
8569   # Extract the first word of "$ac_prog", so it can be a program name with args.
8570 set dummy $ac_prog; ac_word=$2
8571 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8572 $as_echo_n "checking for $ac_word... " >&6; }
8573 if ${ac_cv_path_PRINTF+:} false; then :
8574   $as_echo_n "(cached) " >&6
8575 else
8576   case $PRINTF in
8577   [\\/]* | ?:[\\/]*)
8578   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8579   ;;
8580   *)
8581   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8582 for as_dir in $PATH
8583 do
8584   IFS=$as_save_IFS
8585   test -z "$as_dir" && as_dir=.
8586     for ac_exec_ext in '' $ac_executable_extensions; do
8587   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8588     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8589     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8590     break 2
8591   fi
8592 done
8593   done
8594 IFS=$as_save_IFS
8595 
8596   ;;
8597 esac
8598 fi
8599 PRINTF=$ac_cv_path_PRINTF
8600 if test -n "$PRINTF"; then
8601   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8602 $as_echo "$PRINTF" >&6; }
8603 else
8604   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8605 $as_echo "no" >&6; }
8606 fi
8607 
8608 
8609   test -n "$PRINTF" && break
8610 done
8611 
8612   else
8613     # The variable is set, but is it from the command line or the environment?
8614 
8615     # Try to remove the string !PRINTF! from our list.
8616     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
8617     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8618       # If it failed, the variable was not from the command line. Ignore it,
8619       # but warn the user (except for BASH, which is always set by the calling BASH).
8620       if test "xPRINTF" != xBASH; then
8621         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
8622 $as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
8623       fi
8624       # Try to locate tool using the code snippet
8625       for ac_prog in printf
8626 do
8627   # Extract the first word of "$ac_prog", so it can be a program name with args.
8628 set dummy $ac_prog; ac_word=$2
8629 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8630 $as_echo_n "checking for $ac_word... " >&6; }
8631 if ${ac_cv_path_PRINTF+:} false; then :
8632   $as_echo_n "(cached) " >&6
8633 else
8634   case $PRINTF in
8635   [\\/]* | ?:[\\/]*)
8636   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8637   ;;
8638   *)
8639   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8640 for as_dir in $PATH
8641 do
8642   IFS=$as_save_IFS
8643   test -z "$as_dir" && as_dir=.
8644     for ac_exec_ext in '' $ac_executable_extensions; do
8645   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8646     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8647     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8648     break 2
8649   fi
8650 done
8651   done
8652 IFS=$as_save_IFS
8653 
8654   ;;
8655 esac
8656 fi
8657 PRINTF=$ac_cv_path_PRINTF
8658 if test -n "$PRINTF"; then
8659   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8660 $as_echo "$PRINTF" >&6; }
8661 else
8662   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8663 $as_echo "no" >&6; }
8664 fi
8665 
8666 
8667   test -n "$PRINTF" && break
8668 done
8669 
8670     else
8671       # If it succeeded, then it was overridden by the user. We will use it
8672       # for the tool.
8673 
8674       # First remove it from the list of overridden variables, so we can test
8675       # for unknown variables in the end.
8676       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8677 
8678       # Check if the provided tool contains a complete path.
8679       tool_specified="$PRINTF"
8680       tool_basename="${tool_specified##*/}"
8681       if test "x$tool_basename" = "x$tool_specified"; then
8682         # A command without a complete path is provided, search $PATH.
8683         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
8684 $as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
8685         # Extract the first word of "$tool_basename", so it can be a program name with args.
8686 set dummy $tool_basename; ac_word=$2
8687 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8688 $as_echo_n "checking for $ac_word... " >&6; }
8689 if ${ac_cv_path_PRINTF+:} false; then :
8690   $as_echo_n "(cached) " >&6
8691 else
8692   case $PRINTF in
8693   [\\/]* | ?:[\\/]*)
8694   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8695   ;;
8696   *)
8697   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8698 for as_dir in $PATH
8699 do
8700   IFS=$as_save_IFS
8701   test -z "$as_dir" && as_dir=.
8702     for ac_exec_ext in '' $ac_executable_extensions; do
8703   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8704     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8705     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8706     break 2
8707   fi
8708 done
8709   done
8710 IFS=$as_save_IFS
8711 
8712   ;;
8713 esac
8714 fi
8715 PRINTF=$ac_cv_path_PRINTF
8716 if test -n "$PRINTF"; then
8717   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8718 $as_echo "$PRINTF" >&6; }
8719 else
8720   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8721 $as_echo "no" >&6; }
8722 fi
8723 
8724 
8725         if test "x$PRINTF" = x; then
8726           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8727         fi
8728       else
8729         # Otherwise we believe it is a complete path. Use it as it is.
8730         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
8731 $as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
8732         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
8733 $as_echo_n "checking for PRINTF... " >&6; }
8734         if test ! -x "$tool_specified"; then
8735           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8736 $as_echo "not found" >&6; }
8737           as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
8738         fi
8739         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8740 $as_echo "$tool_specified" >&6; }
8741       fi
8742     fi
8743   fi
8744 
8745 
8746 
8747   if test "x$PRINTF" = x; then
8748     as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
8749   fi
8750 
8751 
8752 
8753 
8754 
8755   # Publish this variable in the help.
8756 
8757 
8758   if test "x$RM" = x; then
8759     # The variable is not set by user, try to locate tool using the code snippet
8760     for ac_prog in rm
8761 do
8762   # Extract the first word of "$ac_prog", so it can be a program name with args.
8763 set dummy $ac_prog; ac_word=$2
8764 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8765 $as_echo_n "checking for $ac_word... " >&6; }
8766 if ${ac_cv_path_RM+:} false; then :
8767   $as_echo_n "(cached) " >&6
8768 else
8769   case $RM in
8770   [\\/]* | ?:[\\/]*)
8771   ac_cv_path_RM="$RM" # Let the user override the test with a path.
8772   ;;
8773   *)
8774   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8775 for as_dir in $PATH
8776 do
8777   IFS=$as_save_IFS
8778   test -z "$as_dir" && as_dir=.
8779     for ac_exec_ext in '' $ac_executable_extensions; do
8780   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8781     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8782     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8783     break 2
8784   fi
8785 done
8786   done
8787 IFS=$as_save_IFS
8788 
8789   ;;
8790 esac
8791 fi
8792 RM=$ac_cv_path_RM
8793 if test -n "$RM"; then
8794   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8795 $as_echo "$RM" >&6; }
8796 else
8797   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8798 $as_echo "no" >&6; }
8799 fi
8800 
8801 
8802   test -n "$RM" && break
8803 done
8804 
8805   else
8806     # The variable is set, but is it from the command line or the environment?
8807 
8808     # Try to remove the string !RM! from our list.
8809     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
8810     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8811       # If it failed, the variable was not from the command line. Ignore it,
8812       # but warn the user (except for BASH, which is always set by the calling BASH).
8813       if test "xRM" != xBASH; then
8814         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
8815 $as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
8816       fi
8817       # Try to locate tool using the code snippet
8818       for ac_prog in rm
8819 do
8820   # Extract the first word of "$ac_prog", so it can be a program name with args.
8821 set dummy $ac_prog; ac_word=$2
8822 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8823 $as_echo_n "checking for $ac_word... " >&6; }
8824 if ${ac_cv_path_RM+:} false; then :
8825   $as_echo_n "(cached) " >&6
8826 else
8827   case $RM in
8828   [\\/]* | ?:[\\/]*)
8829   ac_cv_path_RM="$RM" # Let the user override the test with a path.
8830   ;;
8831   *)
8832   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8833 for as_dir in $PATH
8834 do
8835   IFS=$as_save_IFS
8836   test -z "$as_dir" && as_dir=.
8837     for ac_exec_ext in '' $ac_executable_extensions; do
8838   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8839     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8840     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8841     break 2
8842   fi
8843 done
8844   done
8845 IFS=$as_save_IFS
8846 
8847   ;;
8848 esac
8849 fi
8850 RM=$ac_cv_path_RM
8851 if test -n "$RM"; then
8852   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8853 $as_echo "$RM" >&6; }
8854 else
8855   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8856 $as_echo "no" >&6; }
8857 fi
8858 
8859 
8860   test -n "$RM" && break
8861 done
8862 
8863     else
8864       # If it succeeded, then it was overridden by the user. We will use it
8865       # for the tool.
8866 
8867       # First remove it from the list of overridden variables, so we can test
8868       # for unknown variables in the end.
8869       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8870 
8871       # Check if the provided tool contains a complete path.
8872       tool_specified="$RM"
8873       tool_basename="${tool_specified##*/}"
8874       if test "x$tool_basename" = "x$tool_specified"; then
8875         # A command without a complete path is provided, search $PATH.
8876         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
8877 $as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
8878         # Extract the first word of "$tool_basename", so it can be a program name with args.
8879 set dummy $tool_basename; ac_word=$2
8880 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8881 $as_echo_n "checking for $ac_word... " >&6; }
8882 if ${ac_cv_path_RM+:} false; then :
8883   $as_echo_n "(cached) " >&6
8884 else
8885   case $RM in
8886   [\\/]* | ?:[\\/]*)
8887   ac_cv_path_RM="$RM" # Let the user override the test with a path.
8888   ;;
8889   *)
8890   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8891 for as_dir in $PATH
8892 do
8893   IFS=$as_save_IFS
8894   test -z "$as_dir" && as_dir=.
8895     for ac_exec_ext in '' $ac_executable_extensions; do
8896   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8897     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8898     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8899     break 2
8900   fi
8901 done
8902   done
8903 IFS=$as_save_IFS
8904 
8905   ;;
8906 esac
8907 fi
8908 RM=$ac_cv_path_RM
8909 if test -n "$RM"; then
8910   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8911 $as_echo "$RM" >&6; }
8912 else
8913   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8914 $as_echo "no" >&6; }
8915 fi
8916 
8917 
8918         if test "x$RM" = x; then
8919           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8920         fi
8921       else
8922         # Otherwise we believe it is a complete path. Use it as it is.
8923         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
8924 $as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
8925         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
8926 $as_echo_n "checking for RM... " >&6; }
8927         if test ! -x "$tool_specified"; then
8928           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8929 $as_echo "not found" >&6; }
8930           as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
8931         fi
8932         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8933 $as_echo "$tool_specified" >&6; }
8934       fi
8935     fi
8936   fi
8937 
8938 
8939 
8940   if test "x$RM" = x; then
8941     as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
8942   fi
8943 
8944 
8945 
8946 
8947 
8948   # Publish this variable in the help.
8949 
8950 
8951   if test "x$SH" = x; then
8952     # The variable is not set by user, try to locate tool using the code snippet
8953     for ac_prog in sh
8954 do
8955   # Extract the first word of "$ac_prog", so it can be a program name with args.
8956 set dummy $ac_prog; ac_word=$2
8957 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8958 $as_echo_n "checking for $ac_word... " >&6; }
8959 if ${ac_cv_path_SH+:} false; then :
8960   $as_echo_n "(cached) " >&6
8961 else
8962   case $SH in
8963   [\\/]* | ?:[\\/]*)
8964   ac_cv_path_SH="$SH" # Let the user override the test with a path.
8965   ;;
8966   *)
8967   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8968 for as_dir in $PATH
8969 do
8970   IFS=$as_save_IFS
8971   test -z "$as_dir" && as_dir=.
8972     for ac_exec_ext in '' $ac_executable_extensions; do
8973   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8974     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
8975     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8976     break 2
8977   fi
8978 done
8979   done
8980 IFS=$as_save_IFS
8981 
8982   ;;
8983 esac
8984 fi
8985 SH=$ac_cv_path_SH
8986 if test -n "$SH"; then
8987   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
8988 $as_echo "$SH" >&6; }
8989 else
8990   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8991 $as_echo "no" >&6; }
8992 fi
8993 
8994 
8995   test -n "$SH" && break
8996 done
8997 
8998   else
8999     # The variable is set, but is it from the command line or the environment?
9000 
9001     # Try to remove the string !SH! from our list.
9002     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
9003     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9004       # If it failed, the variable was not from the command line. Ignore it,
9005       # but warn the user (except for BASH, which is always set by the calling BASH).
9006       if test "xSH" != xBASH; then
9007         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
9008 $as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
9009       fi
9010       # Try to locate tool using the code snippet
9011       for ac_prog in sh
9012 do
9013   # Extract the first word of "$ac_prog", so it can be a program name with args.
9014 set dummy $ac_prog; ac_word=$2
9015 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9016 $as_echo_n "checking for $ac_word... " >&6; }
9017 if ${ac_cv_path_SH+:} false; then :
9018   $as_echo_n "(cached) " >&6
9019 else
9020   case $SH in
9021   [\\/]* | ?:[\\/]*)
9022   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9023   ;;
9024   *)
9025   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9026 for as_dir in $PATH
9027 do
9028   IFS=$as_save_IFS
9029   test -z "$as_dir" && as_dir=.
9030     for ac_exec_ext in '' $ac_executable_extensions; do
9031   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9032     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9033     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9034     break 2
9035   fi
9036 done
9037   done
9038 IFS=$as_save_IFS
9039 
9040   ;;
9041 esac
9042 fi
9043 SH=$ac_cv_path_SH
9044 if test -n "$SH"; then
9045   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9046 $as_echo "$SH" >&6; }
9047 else
9048   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9049 $as_echo "no" >&6; }
9050 fi
9051 
9052 
9053   test -n "$SH" && break
9054 done
9055 
9056     else
9057       # If it succeeded, then it was overridden by the user. We will use it
9058       # for the tool.
9059 
9060       # First remove it from the list of overridden variables, so we can test
9061       # for unknown variables in the end.
9062       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9063 
9064       # Check if the provided tool contains a complete path.
9065       tool_specified="$SH"
9066       tool_basename="${tool_specified##*/}"
9067       if test "x$tool_basename" = "x$tool_specified"; then
9068         # A command without a complete path is provided, search $PATH.
9069         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
9070 $as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
9071         # Extract the first word of "$tool_basename", so it can be a program name with args.
9072 set dummy $tool_basename; ac_word=$2
9073 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9074 $as_echo_n "checking for $ac_word... " >&6; }
9075 if ${ac_cv_path_SH+:} false; then :
9076   $as_echo_n "(cached) " >&6
9077 else
9078   case $SH in
9079   [\\/]* | ?:[\\/]*)
9080   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9081   ;;
9082   *)
9083   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9084 for as_dir in $PATH
9085 do
9086   IFS=$as_save_IFS
9087   test -z "$as_dir" && as_dir=.
9088     for ac_exec_ext in '' $ac_executable_extensions; do
9089   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9090     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9091     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9092     break 2
9093   fi
9094 done
9095   done
9096 IFS=$as_save_IFS
9097 
9098   ;;
9099 esac
9100 fi
9101 SH=$ac_cv_path_SH
9102 if test -n "$SH"; then
9103   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9104 $as_echo "$SH" >&6; }
9105 else
9106   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9107 $as_echo "no" >&6; }
9108 fi
9109 
9110 
9111         if test "x$SH" = x; then
9112           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9113         fi
9114       else
9115         # Otherwise we believe it is a complete path. Use it as it is.
9116         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
9117 $as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
9118         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
9119 $as_echo_n "checking for SH... " >&6; }
9120         if test ! -x "$tool_specified"; then
9121           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9122 $as_echo "not found" >&6; }
9123           as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
9124         fi
9125         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9126 $as_echo "$tool_specified" >&6; }
9127       fi
9128     fi
9129   fi
9130 
9131 
9132 
9133   if test "x$SH" = x; then
9134     as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
9135   fi
9136 
9137 
9138 
9139 
9140 
9141   # Publish this variable in the help.
9142 
9143 
9144   if test "x$SORT" = x; then
9145     # The variable is not set by user, try to locate tool using the code snippet
9146     for ac_prog in sort
9147 do
9148   # Extract the first word of "$ac_prog", so it can be a program name with args.
9149 set dummy $ac_prog; ac_word=$2
9150 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9151 $as_echo_n "checking for $ac_word... " >&6; }
9152 if ${ac_cv_path_SORT+:} false; then :
9153   $as_echo_n "(cached) " >&6
9154 else
9155   case $SORT in
9156   [\\/]* | ?:[\\/]*)
9157   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9158   ;;
9159   *)
9160   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9161 for as_dir in $PATH
9162 do
9163   IFS=$as_save_IFS
9164   test -z "$as_dir" && as_dir=.
9165     for ac_exec_ext in '' $ac_executable_extensions; do
9166   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9167     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9168     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9169     break 2
9170   fi
9171 done
9172   done
9173 IFS=$as_save_IFS
9174 
9175   ;;
9176 esac
9177 fi
9178 SORT=$ac_cv_path_SORT
9179 if test -n "$SORT"; then
9180   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9181 $as_echo "$SORT" >&6; }
9182 else
9183   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9184 $as_echo "no" >&6; }
9185 fi
9186 
9187 
9188   test -n "$SORT" && break
9189 done
9190 
9191   else
9192     # The variable is set, but is it from the command line or the environment?
9193 
9194     # Try to remove the string !SORT! from our list.
9195     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
9196     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9197       # If it failed, the variable was not from the command line. Ignore it,
9198       # but warn the user (except for BASH, which is always set by the calling BASH).
9199       if test "xSORT" != xBASH; then
9200         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
9201 $as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
9202       fi
9203       # Try to locate tool using the code snippet
9204       for ac_prog in sort
9205 do
9206   # Extract the first word of "$ac_prog", so it can be a program name with args.
9207 set dummy $ac_prog; ac_word=$2
9208 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9209 $as_echo_n "checking for $ac_word... " >&6; }
9210 if ${ac_cv_path_SORT+:} false; then :
9211   $as_echo_n "(cached) " >&6
9212 else
9213   case $SORT in
9214   [\\/]* | ?:[\\/]*)
9215   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9216   ;;
9217   *)
9218   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9219 for as_dir in $PATH
9220 do
9221   IFS=$as_save_IFS
9222   test -z "$as_dir" && as_dir=.
9223     for ac_exec_ext in '' $ac_executable_extensions; do
9224   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9225     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9226     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9227     break 2
9228   fi
9229 done
9230   done
9231 IFS=$as_save_IFS
9232 
9233   ;;
9234 esac
9235 fi
9236 SORT=$ac_cv_path_SORT
9237 if test -n "$SORT"; then
9238   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9239 $as_echo "$SORT" >&6; }
9240 else
9241   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9242 $as_echo "no" >&6; }
9243 fi
9244 
9245 
9246   test -n "$SORT" && break
9247 done
9248 
9249     else
9250       # If it succeeded, then it was overridden by the user. We will use it
9251       # for the tool.
9252 
9253       # First remove it from the list of overridden variables, so we can test
9254       # for unknown variables in the end.
9255       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9256 
9257       # Check if the provided tool contains a complete path.
9258       tool_specified="$SORT"
9259       tool_basename="${tool_specified##*/}"
9260       if test "x$tool_basename" = "x$tool_specified"; then
9261         # A command without a complete path is provided, search $PATH.
9262         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
9263 $as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
9264         # Extract the first word of "$tool_basename", so it can be a program name with args.
9265 set dummy $tool_basename; ac_word=$2
9266 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9267 $as_echo_n "checking for $ac_word... " >&6; }
9268 if ${ac_cv_path_SORT+:} false; then :
9269   $as_echo_n "(cached) " >&6
9270 else
9271   case $SORT in
9272   [\\/]* | ?:[\\/]*)
9273   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9274   ;;
9275   *)
9276   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9277 for as_dir in $PATH
9278 do
9279   IFS=$as_save_IFS
9280   test -z "$as_dir" && as_dir=.
9281     for ac_exec_ext in '' $ac_executable_extensions; do
9282   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9283     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9284     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9285     break 2
9286   fi
9287 done
9288   done
9289 IFS=$as_save_IFS
9290 
9291   ;;
9292 esac
9293 fi
9294 SORT=$ac_cv_path_SORT
9295 if test -n "$SORT"; then
9296   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9297 $as_echo "$SORT" >&6; }
9298 else
9299   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9300 $as_echo "no" >&6; }
9301 fi
9302 
9303 
9304         if test "x$SORT" = x; then
9305           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9306         fi
9307       else
9308         # Otherwise we believe it is a complete path. Use it as it is.
9309         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
9310 $as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
9311         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
9312 $as_echo_n "checking for SORT... " >&6; }
9313         if test ! -x "$tool_specified"; then
9314           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9315 $as_echo "not found" >&6; }
9316           as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
9317         fi
9318         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9319 $as_echo "$tool_specified" >&6; }
9320       fi
9321     fi
9322   fi
9323 
9324 
9325 
9326   if test "x$SORT" = x; then
9327     as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
9328   fi
9329 
9330 
9331 
9332 
9333 
9334   # Publish this variable in the help.
9335 
9336 
9337   if test "x$TAIL" = x; then
9338     # The variable is not set by user, try to locate tool using the code snippet
9339     for ac_prog in tail
9340 do
9341   # Extract the first word of "$ac_prog", so it can be a program name with args.
9342 set dummy $ac_prog; ac_word=$2
9343 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9344 $as_echo_n "checking for $ac_word... " >&6; }
9345 if ${ac_cv_path_TAIL+:} false; then :
9346   $as_echo_n "(cached) " >&6
9347 else
9348   case $TAIL in
9349   [\\/]* | ?:[\\/]*)
9350   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9351   ;;
9352   *)
9353   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9354 for as_dir in $PATH
9355 do
9356   IFS=$as_save_IFS
9357   test -z "$as_dir" && as_dir=.
9358     for ac_exec_ext in '' $ac_executable_extensions; do
9359   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9360     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9361     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9362     break 2
9363   fi
9364 done
9365   done
9366 IFS=$as_save_IFS
9367 
9368   ;;
9369 esac
9370 fi
9371 TAIL=$ac_cv_path_TAIL
9372 if test -n "$TAIL"; then
9373   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9374 $as_echo "$TAIL" >&6; }
9375 else
9376   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9377 $as_echo "no" >&6; }
9378 fi
9379 
9380 
9381   test -n "$TAIL" && break
9382 done
9383 
9384   else
9385     # The variable is set, but is it from the command line or the environment?
9386 
9387     # Try to remove the string !TAIL! from our list.
9388     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
9389     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9390       # If it failed, the variable was not from the command line. Ignore it,
9391       # but warn the user (except for BASH, which is always set by the calling BASH).
9392       if test "xTAIL" != xBASH; then
9393         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
9394 $as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
9395       fi
9396       # Try to locate tool using the code snippet
9397       for ac_prog in tail
9398 do
9399   # Extract the first word of "$ac_prog", so it can be a program name with args.
9400 set dummy $ac_prog; ac_word=$2
9401 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9402 $as_echo_n "checking for $ac_word... " >&6; }
9403 if ${ac_cv_path_TAIL+:} false; then :
9404   $as_echo_n "(cached) " >&6
9405 else
9406   case $TAIL in
9407   [\\/]* | ?:[\\/]*)
9408   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9409   ;;
9410   *)
9411   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9412 for as_dir in $PATH
9413 do
9414   IFS=$as_save_IFS
9415   test -z "$as_dir" && as_dir=.
9416     for ac_exec_ext in '' $ac_executable_extensions; do
9417   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9418     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9419     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9420     break 2
9421   fi
9422 done
9423   done
9424 IFS=$as_save_IFS
9425 
9426   ;;
9427 esac
9428 fi
9429 TAIL=$ac_cv_path_TAIL
9430 if test -n "$TAIL"; then
9431   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9432 $as_echo "$TAIL" >&6; }
9433 else
9434   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9435 $as_echo "no" >&6; }
9436 fi
9437 
9438 
9439   test -n "$TAIL" && break
9440 done
9441 
9442     else
9443       # If it succeeded, then it was overridden by the user. We will use it
9444       # for the tool.
9445 
9446       # First remove it from the list of overridden variables, so we can test
9447       # for unknown variables in the end.
9448       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9449 
9450       # Check if the provided tool contains a complete path.
9451       tool_specified="$TAIL"
9452       tool_basename="${tool_specified##*/}"
9453       if test "x$tool_basename" = "x$tool_specified"; then
9454         # A command without a complete path is provided, search $PATH.
9455         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
9456 $as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
9457         # Extract the first word of "$tool_basename", so it can be a program name with args.
9458 set dummy $tool_basename; ac_word=$2
9459 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9460 $as_echo_n "checking for $ac_word... " >&6; }
9461 if ${ac_cv_path_TAIL+:} false; then :
9462   $as_echo_n "(cached) " >&6
9463 else
9464   case $TAIL in
9465   [\\/]* | ?:[\\/]*)
9466   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9467   ;;
9468   *)
9469   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9470 for as_dir in $PATH
9471 do
9472   IFS=$as_save_IFS
9473   test -z "$as_dir" && as_dir=.
9474     for ac_exec_ext in '' $ac_executable_extensions; do
9475   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9476     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9477     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9478     break 2
9479   fi
9480 done
9481   done
9482 IFS=$as_save_IFS
9483 
9484   ;;
9485 esac
9486 fi
9487 TAIL=$ac_cv_path_TAIL
9488 if test -n "$TAIL"; then
9489   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9490 $as_echo "$TAIL" >&6; }
9491 else
9492   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9493 $as_echo "no" >&6; }
9494 fi
9495 
9496 
9497         if test "x$TAIL" = x; then
9498           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9499         fi
9500       else
9501         # Otherwise we believe it is a complete path. Use it as it is.
9502         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
9503 $as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
9504         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
9505 $as_echo_n "checking for TAIL... " >&6; }
9506         if test ! -x "$tool_specified"; then
9507           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9508 $as_echo "not found" >&6; }
9509           as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
9510         fi
9511         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9512 $as_echo "$tool_specified" >&6; }
9513       fi
9514     fi
9515   fi
9516 
9517 
9518 
9519   if test "x$TAIL" = x; then
9520     as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
9521   fi
9522 
9523 
9524 
9525 
9526 
9527   # Publish this variable in the help.
9528 
9529 
9530   if test "x$TAR" = x; then
9531     # The variable is not set by user, try to locate tool using the code snippet
9532     for ac_prog in tar
9533 do
9534   # Extract the first word of "$ac_prog", so it can be a program name with args.
9535 set dummy $ac_prog; ac_word=$2
9536 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9537 $as_echo_n "checking for $ac_word... " >&6; }
9538 if ${ac_cv_path_TAR+:} false; then :
9539   $as_echo_n "(cached) " >&6
9540 else
9541   case $TAR in
9542   [\\/]* | ?:[\\/]*)
9543   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9544   ;;
9545   *)
9546   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9547 for as_dir in $PATH
9548 do
9549   IFS=$as_save_IFS
9550   test -z "$as_dir" && as_dir=.
9551     for ac_exec_ext in '' $ac_executable_extensions; do
9552   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9553     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9554     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9555     break 2
9556   fi
9557 done
9558   done
9559 IFS=$as_save_IFS
9560 
9561   ;;
9562 esac
9563 fi
9564 TAR=$ac_cv_path_TAR
9565 if test -n "$TAR"; then
9566   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9567 $as_echo "$TAR" >&6; }
9568 else
9569   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9570 $as_echo "no" >&6; }
9571 fi
9572 
9573 
9574   test -n "$TAR" && break
9575 done
9576 
9577   else
9578     # The variable is set, but is it from the command line or the environment?
9579 
9580     # Try to remove the string !TAR! from our list.
9581     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
9582     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9583       # If it failed, the variable was not from the command line. Ignore it,
9584       # but warn the user (except for BASH, which is always set by the calling BASH).
9585       if test "xTAR" != xBASH; then
9586         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
9587 $as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
9588       fi
9589       # Try to locate tool using the code snippet
9590       for ac_prog in tar
9591 do
9592   # Extract the first word of "$ac_prog", so it can be a program name with args.
9593 set dummy $ac_prog; ac_word=$2
9594 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9595 $as_echo_n "checking for $ac_word... " >&6; }
9596 if ${ac_cv_path_TAR+:} false; then :
9597   $as_echo_n "(cached) " >&6
9598 else
9599   case $TAR in
9600   [\\/]* | ?:[\\/]*)
9601   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9602   ;;
9603   *)
9604   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9605 for as_dir in $PATH
9606 do
9607   IFS=$as_save_IFS
9608   test -z "$as_dir" && as_dir=.
9609     for ac_exec_ext in '' $ac_executable_extensions; do
9610   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9611     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9612     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9613     break 2
9614   fi
9615 done
9616   done
9617 IFS=$as_save_IFS
9618 
9619   ;;
9620 esac
9621 fi
9622 TAR=$ac_cv_path_TAR
9623 if test -n "$TAR"; then
9624   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9625 $as_echo "$TAR" >&6; }
9626 else
9627   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9628 $as_echo "no" >&6; }
9629 fi
9630 
9631 
9632   test -n "$TAR" && break
9633 done
9634 
9635     else
9636       # If it succeeded, then it was overridden by the user. We will use it
9637       # for the tool.
9638 
9639       # First remove it from the list of overridden variables, so we can test
9640       # for unknown variables in the end.
9641       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9642 
9643       # Check if the provided tool contains a complete path.
9644       tool_specified="$TAR"
9645       tool_basename="${tool_specified##*/}"
9646       if test "x$tool_basename" = "x$tool_specified"; then
9647         # A command without a complete path is provided, search $PATH.
9648         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
9649 $as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
9650         # Extract the first word of "$tool_basename", so it can be a program name with args.
9651 set dummy $tool_basename; ac_word=$2
9652 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9653 $as_echo_n "checking for $ac_word... " >&6; }
9654 if ${ac_cv_path_TAR+:} false; then :
9655   $as_echo_n "(cached) " >&6
9656 else
9657   case $TAR in
9658   [\\/]* | ?:[\\/]*)
9659   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9660   ;;
9661   *)
9662   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9663 for as_dir in $PATH
9664 do
9665   IFS=$as_save_IFS
9666   test -z "$as_dir" && as_dir=.
9667     for ac_exec_ext in '' $ac_executable_extensions; do
9668   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9669     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9670     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9671     break 2
9672   fi
9673 done
9674   done
9675 IFS=$as_save_IFS
9676 
9677   ;;
9678 esac
9679 fi
9680 TAR=$ac_cv_path_TAR
9681 if test -n "$TAR"; then
9682   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9683 $as_echo "$TAR" >&6; }
9684 else
9685   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9686 $as_echo "no" >&6; }
9687 fi
9688 
9689 
9690         if test "x$TAR" = x; then
9691           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9692         fi
9693       else
9694         # Otherwise we believe it is a complete path. Use it as it is.
9695         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
9696 $as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
9697         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
9698 $as_echo_n "checking for TAR... " >&6; }
9699         if test ! -x "$tool_specified"; then
9700           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9701 $as_echo "not found" >&6; }
9702           as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
9703         fi
9704         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9705 $as_echo "$tool_specified" >&6; }
9706       fi
9707     fi
9708   fi
9709 
9710 
9711 
9712   if test "x$TAR" = x; then
9713     as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
9714   fi
9715 
9716 
9717 
9718 
9719 
9720   # Publish this variable in the help.
9721 
9722 
9723   if test "x$TEE" = x; then
9724     # The variable is not set by user, try to locate tool using the code snippet
9725     for ac_prog in tee
9726 do
9727   # Extract the first word of "$ac_prog", so it can be a program name with args.
9728 set dummy $ac_prog; ac_word=$2
9729 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9730 $as_echo_n "checking for $ac_word... " >&6; }
9731 if ${ac_cv_path_TEE+:} false; then :
9732   $as_echo_n "(cached) " >&6
9733 else
9734   case $TEE in
9735   [\\/]* | ?:[\\/]*)
9736   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9737   ;;
9738   *)
9739   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9740 for as_dir in $PATH
9741 do
9742   IFS=$as_save_IFS
9743   test -z "$as_dir" && as_dir=.
9744     for ac_exec_ext in '' $ac_executable_extensions; do
9745   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9746     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9747     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9748     break 2
9749   fi
9750 done
9751   done
9752 IFS=$as_save_IFS
9753 
9754   ;;
9755 esac
9756 fi
9757 TEE=$ac_cv_path_TEE
9758 if test -n "$TEE"; then
9759   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9760 $as_echo "$TEE" >&6; }
9761 else
9762   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9763 $as_echo "no" >&6; }
9764 fi
9765 
9766 
9767   test -n "$TEE" && break
9768 done
9769 
9770   else
9771     # The variable is set, but is it from the command line or the environment?
9772 
9773     # Try to remove the string !TEE! from our list.
9774     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
9775     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9776       # If it failed, the variable was not from the command line. Ignore it,
9777       # but warn the user (except for BASH, which is always set by the calling BASH).
9778       if test "xTEE" != xBASH; then
9779         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
9780 $as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
9781       fi
9782       # Try to locate tool using the code snippet
9783       for ac_prog in tee
9784 do
9785   # Extract the first word of "$ac_prog", so it can be a program name with args.
9786 set dummy $ac_prog; ac_word=$2
9787 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9788 $as_echo_n "checking for $ac_word... " >&6; }
9789 if ${ac_cv_path_TEE+:} false; then :
9790   $as_echo_n "(cached) " >&6
9791 else
9792   case $TEE in
9793   [\\/]* | ?:[\\/]*)
9794   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9795   ;;
9796   *)
9797   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9798 for as_dir in $PATH
9799 do
9800   IFS=$as_save_IFS
9801   test -z "$as_dir" && as_dir=.
9802     for ac_exec_ext in '' $ac_executable_extensions; do
9803   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9804     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9805     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9806     break 2
9807   fi
9808 done
9809   done
9810 IFS=$as_save_IFS
9811 
9812   ;;
9813 esac
9814 fi
9815 TEE=$ac_cv_path_TEE
9816 if test -n "$TEE"; then
9817   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9818 $as_echo "$TEE" >&6; }
9819 else
9820   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9821 $as_echo "no" >&6; }
9822 fi
9823 
9824 
9825   test -n "$TEE" && break
9826 done
9827 
9828     else
9829       # If it succeeded, then it was overridden by the user. We will use it
9830       # for the tool.
9831 
9832       # First remove it from the list of overridden variables, so we can test
9833       # for unknown variables in the end.
9834       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9835 
9836       # Check if the provided tool contains a complete path.
9837       tool_specified="$TEE"
9838       tool_basename="${tool_specified##*/}"
9839       if test "x$tool_basename" = "x$tool_specified"; then
9840         # A command without a complete path is provided, search $PATH.
9841         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
9842 $as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
9843         # Extract the first word of "$tool_basename", so it can be a program name with args.
9844 set dummy $tool_basename; ac_word=$2
9845 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9846 $as_echo_n "checking for $ac_word... " >&6; }
9847 if ${ac_cv_path_TEE+:} false; then :
9848   $as_echo_n "(cached) " >&6
9849 else
9850   case $TEE in
9851   [\\/]* | ?:[\\/]*)
9852   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9853   ;;
9854   *)
9855   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9856 for as_dir in $PATH
9857 do
9858   IFS=$as_save_IFS
9859   test -z "$as_dir" && as_dir=.
9860     for ac_exec_ext in '' $ac_executable_extensions; do
9861   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9862     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9863     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9864     break 2
9865   fi
9866 done
9867   done
9868 IFS=$as_save_IFS
9869 
9870   ;;
9871 esac
9872 fi
9873 TEE=$ac_cv_path_TEE
9874 if test -n "$TEE"; then
9875   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9876 $as_echo "$TEE" >&6; }
9877 else
9878   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9879 $as_echo "no" >&6; }
9880 fi
9881 
9882 
9883         if test "x$TEE" = x; then
9884           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9885         fi
9886       else
9887         # Otherwise we believe it is a complete path. Use it as it is.
9888         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
9889 $as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
9890         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
9891 $as_echo_n "checking for TEE... " >&6; }
9892         if test ! -x "$tool_specified"; then
9893           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9894 $as_echo "not found" >&6; }
9895           as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
9896         fi
9897         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9898 $as_echo "$tool_specified" >&6; }
9899       fi
9900     fi
9901   fi
9902 
9903 
9904 
9905   if test "x$TEE" = x; then
9906     as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
9907   fi
9908 
9909 
9910 
9911 
9912 
9913   # Publish this variable in the help.
9914 
9915 
9916   if test "x$TOUCH" = x; then
9917     # The variable is not set by user, try to locate tool using the code snippet
9918     for ac_prog in touch
9919 do
9920   # Extract the first word of "$ac_prog", so it can be a program name with args.
9921 set dummy $ac_prog; ac_word=$2
9922 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9923 $as_echo_n "checking for $ac_word... " >&6; }
9924 if ${ac_cv_path_TOUCH+:} false; then :
9925   $as_echo_n "(cached) " >&6
9926 else
9927   case $TOUCH in
9928   [\\/]* | ?:[\\/]*)
9929   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
9930   ;;
9931   *)
9932   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9933 for as_dir in $PATH
9934 do
9935   IFS=$as_save_IFS
9936   test -z "$as_dir" && as_dir=.
9937     for ac_exec_ext in '' $ac_executable_extensions; do
9938   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9939     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
9940     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9941     break 2
9942   fi
9943 done
9944   done
9945 IFS=$as_save_IFS
9946 
9947   ;;
9948 esac
9949 fi
9950 TOUCH=$ac_cv_path_TOUCH
9951 if test -n "$TOUCH"; then
9952   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
9953 $as_echo "$TOUCH" >&6; }
9954 else
9955   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9956 $as_echo "no" >&6; }
9957 fi
9958 
9959 
9960   test -n "$TOUCH" && break
9961 done
9962 
9963   else
9964     # The variable is set, but is it from the command line or the environment?
9965 
9966     # Try to remove the string !TOUCH! from our list.
9967     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
9968     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9969       # If it failed, the variable was not from the command line. Ignore it,
9970       # but warn the user (except for BASH, which is always set by the calling BASH).
9971       if test "xTOUCH" != xBASH; then
9972         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
9973 $as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
9974       fi
9975       # Try to locate tool using the code snippet
9976       for ac_prog in touch
9977 do
9978   # Extract the first word of "$ac_prog", so it can be a program name with args.
9979 set dummy $ac_prog; ac_word=$2
9980 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9981 $as_echo_n "checking for $ac_word... " >&6; }
9982 if ${ac_cv_path_TOUCH+:} false; then :
9983   $as_echo_n "(cached) " >&6
9984 else
9985   case $TOUCH in
9986   [\\/]* | ?:[\\/]*)
9987   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
9988   ;;
9989   *)
9990   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9991 for as_dir in $PATH
9992 do
9993   IFS=$as_save_IFS
9994   test -z "$as_dir" && as_dir=.
9995     for ac_exec_ext in '' $ac_executable_extensions; do
9996   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9997     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
9998     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9999     break 2
10000   fi
10001 done
10002   done
10003 IFS=$as_save_IFS
10004 
10005   ;;
10006 esac
10007 fi
10008 TOUCH=$ac_cv_path_TOUCH
10009 if test -n "$TOUCH"; then
10010   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10011 $as_echo "$TOUCH" >&6; }
10012 else
10013   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10014 $as_echo "no" >&6; }
10015 fi
10016 
10017 
10018   test -n "$TOUCH" && break
10019 done
10020 
10021     else
10022       # If it succeeded, then it was overridden by the user. We will use it
10023       # for the tool.
10024 
10025       # First remove it from the list of overridden variables, so we can test
10026       # for unknown variables in the end.
10027       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10028 
10029       # Check if the provided tool contains a complete path.
10030       tool_specified="$TOUCH"
10031       tool_basename="${tool_specified##*/}"
10032       if test "x$tool_basename" = "x$tool_specified"; then
10033         # A command without a complete path is provided, search $PATH.
10034         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
10035 $as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
10036         # Extract the first word of "$tool_basename", so it can be a program name with args.
10037 set dummy $tool_basename; ac_word=$2
10038 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10039 $as_echo_n "checking for $ac_word... " >&6; }
10040 if ${ac_cv_path_TOUCH+:} false; then :
10041   $as_echo_n "(cached) " >&6
10042 else
10043   case $TOUCH in
10044   [\\/]* | ?:[\\/]*)
10045   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10046   ;;
10047   *)
10048   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10049 for as_dir in $PATH
10050 do
10051   IFS=$as_save_IFS
10052   test -z "$as_dir" && as_dir=.
10053     for ac_exec_ext in '' $ac_executable_extensions; do
10054   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10055     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10056     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10057     break 2
10058   fi
10059 done
10060   done
10061 IFS=$as_save_IFS
10062 
10063   ;;
10064 esac
10065 fi
10066 TOUCH=$ac_cv_path_TOUCH
10067 if test -n "$TOUCH"; then
10068   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10069 $as_echo "$TOUCH" >&6; }
10070 else
10071   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10072 $as_echo "no" >&6; }
10073 fi
10074 
10075 
10076         if test "x$TOUCH" = x; then
10077           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10078         fi
10079       else
10080         # Otherwise we believe it is a complete path. Use it as it is.
10081         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
10082 $as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
10083         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
10084 $as_echo_n "checking for TOUCH... " >&6; }
10085         if test ! -x "$tool_specified"; then
10086           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10087 $as_echo "not found" >&6; }
10088           as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
10089         fi
10090         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10091 $as_echo "$tool_specified" >&6; }
10092       fi
10093     fi
10094   fi
10095 
10096 
10097 
10098   if test "x$TOUCH" = x; then
10099     as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
10100   fi
10101 
10102 
10103 
10104 
10105 
10106   # Publish this variable in the help.
10107 
10108 
10109   if test "x$TR" = x; then
10110     # The variable is not set by user, try to locate tool using the code snippet
10111     for ac_prog in tr
10112 do
10113   # Extract the first word of "$ac_prog", so it can be a program name with args.
10114 set dummy $ac_prog; ac_word=$2
10115 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10116 $as_echo_n "checking for $ac_word... " >&6; }
10117 if ${ac_cv_path_TR+:} false; then :
10118   $as_echo_n "(cached) " >&6
10119 else
10120   case $TR in
10121   [\\/]* | ?:[\\/]*)
10122   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10123   ;;
10124   *)
10125   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10126 for as_dir in $PATH
10127 do
10128   IFS=$as_save_IFS
10129   test -z "$as_dir" && as_dir=.
10130     for ac_exec_ext in '' $ac_executable_extensions; do
10131   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10132     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10133     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10134     break 2
10135   fi
10136 done
10137   done
10138 IFS=$as_save_IFS
10139 
10140   ;;
10141 esac
10142 fi
10143 TR=$ac_cv_path_TR
10144 if test -n "$TR"; then
10145   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10146 $as_echo "$TR" >&6; }
10147 else
10148   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10149 $as_echo "no" >&6; }
10150 fi
10151 
10152 
10153   test -n "$TR" && break
10154 done
10155 
10156   else
10157     # The variable is set, but is it from the command line or the environment?
10158 
10159     # Try to remove the string !TR! from our list.
10160     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
10161     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10162       # If it failed, the variable was not from the command line. Ignore it,
10163       # but warn the user (except for BASH, which is always set by the calling BASH).
10164       if test "xTR" != xBASH; then
10165         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
10166 $as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
10167       fi
10168       # Try to locate tool using the code snippet
10169       for ac_prog in tr
10170 do
10171   # Extract the first word of "$ac_prog", so it can be a program name with args.
10172 set dummy $ac_prog; ac_word=$2
10173 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10174 $as_echo_n "checking for $ac_word... " >&6; }
10175 if ${ac_cv_path_TR+:} false; then :
10176   $as_echo_n "(cached) " >&6
10177 else
10178   case $TR in
10179   [\\/]* | ?:[\\/]*)
10180   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10181   ;;
10182   *)
10183   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10184 for as_dir in $PATH
10185 do
10186   IFS=$as_save_IFS
10187   test -z "$as_dir" && as_dir=.
10188     for ac_exec_ext in '' $ac_executable_extensions; do
10189   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10190     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10191     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10192     break 2
10193   fi
10194 done
10195   done
10196 IFS=$as_save_IFS
10197 
10198   ;;
10199 esac
10200 fi
10201 TR=$ac_cv_path_TR
10202 if test -n "$TR"; then
10203   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10204 $as_echo "$TR" >&6; }
10205 else
10206   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10207 $as_echo "no" >&6; }
10208 fi
10209 
10210 
10211   test -n "$TR" && break
10212 done
10213 
10214     else
10215       # If it succeeded, then it was overridden by the user. We will use it
10216       # for the tool.
10217 
10218       # First remove it from the list of overridden variables, so we can test
10219       # for unknown variables in the end.
10220       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10221 
10222       # Check if the provided tool contains a complete path.
10223       tool_specified="$TR"
10224       tool_basename="${tool_specified##*/}"
10225       if test "x$tool_basename" = "x$tool_specified"; then
10226         # A command without a complete path is provided, search $PATH.
10227         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
10228 $as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
10229         # Extract the first word of "$tool_basename", so it can be a program name with args.
10230 set dummy $tool_basename; ac_word=$2
10231 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10232 $as_echo_n "checking for $ac_word... " >&6; }
10233 if ${ac_cv_path_TR+:} false; then :
10234   $as_echo_n "(cached) " >&6
10235 else
10236   case $TR in
10237   [\\/]* | ?:[\\/]*)
10238   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10239   ;;
10240   *)
10241   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10242 for as_dir in $PATH
10243 do
10244   IFS=$as_save_IFS
10245   test -z "$as_dir" && as_dir=.
10246     for ac_exec_ext in '' $ac_executable_extensions; do
10247   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10248     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10249     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10250     break 2
10251   fi
10252 done
10253   done
10254 IFS=$as_save_IFS
10255 
10256   ;;
10257 esac
10258 fi
10259 TR=$ac_cv_path_TR
10260 if test -n "$TR"; then
10261   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10262 $as_echo "$TR" >&6; }
10263 else
10264   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10265 $as_echo "no" >&6; }
10266 fi
10267 
10268 
10269         if test "x$TR" = x; then
10270           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10271         fi
10272       else
10273         # Otherwise we believe it is a complete path. Use it as it is.
10274         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
10275 $as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
10276         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
10277 $as_echo_n "checking for TR... " >&6; }
10278         if test ! -x "$tool_specified"; then
10279           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10280 $as_echo "not found" >&6; }
10281           as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
10282         fi
10283         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10284 $as_echo "$tool_specified" >&6; }
10285       fi
10286     fi
10287   fi
10288 
10289 
10290 
10291   if test "x$TR" = x; then
10292     as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
10293   fi
10294 
10295 
10296 
10297 
10298 
10299   # Publish this variable in the help.
10300 
10301 
10302   if test "x$UNAME" = x; then
10303     # The variable is not set by user, try to locate tool using the code snippet
10304     for ac_prog in uname
10305 do
10306   # Extract the first word of "$ac_prog", so it can be a program name with args.
10307 set dummy $ac_prog; ac_word=$2
10308 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10309 $as_echo_n "checking for $ac_word... " >&6; }
10310 if ${ac_cv_path_UNAME+:} false; then :
10311   $as_echo_n "(cached) " >&6
10312 else
10313   case $UNAME in
10314   [\\/]* | ?:[\\/]*)
10315   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10316   ;;
10317   *)
10318   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10319 for as_dir in $PATH
10320 do
10321   IFS=$as_save_IFS
10322   test -z "$as_dir" && as_dir=.
10323     for ac_exec_ext in '' $ac_executable_extensions; do
10324   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10325     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10326     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10327     break 2
10328   fi
10329 done
10330   done
10331 IFS=$as_save_IFS
10332 
10333   ;;
10334 esac
10335 fi
10336 UNAME=$ac_cv_path_UNAME
10337 if test -n "$UNAME"; then
10338   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10339 $as_echo "$UNAME" >&6; }
10340 else
10341   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10342 $as_echo "no" >&6; }
10343 fi
10344 
10345 
10346   test -n "$UNAME" && break
10347 done
10348 
10349   else
10350     # The variable is set, but is it from the command line or the environment?
10351 
10352     # Try to remove the string !UNAME! from our list.
10353     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
10354     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10355       # If it failed, the variable was not from the command line. Ignore it,
10356       # but warn the user (except for BASH, which is always set by the calling BASH).
10357       if test "xUNAME" != xBASH; then
10358         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
10359 $as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
10360       fi
10361       # Try to locate tool using the code snippet
10362       for ac_prog in uname
10363 do
10364   # Extract the first word of "$ac_prog", so it can be a program name with args.
10365 set dummy $ac_prog; ac_word=$2
10366 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10367 $as_echo_n "checking for $ac_word... " >&6; }
10368 if ${ac_cv_path_UNAME+:} false; then :
10369   $as_echo_n "(cached) " >&6
10370 else
10371   case $UNAME in
10372   [\\/]* | ?:[\\/]*)
10373   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10374   ;;
10375   *)
10376   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10377 for as_dir in $PATH
10378 do
10379   IFS=$as_save_IFS
10380   test -z "$as_dir" && as_dir=.
10381     for ac_exec_ext in '' $ac_executable_extensions; do
10382   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10383     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10384     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10385     break 2
10386   fi
10387 done
10388   done
10389 IFS=$as_save_IFS
10390 
10391   ;;
10392 esac
10393 fi
10394 UNAME=$ac_cv_path_UNAME
10395 if test -n "$UNAME"; then
10396   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10397 $as_echo "$UNAME" >&6; }
10398 else
10399   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10400 $as_echo "no" >&6; }
10401 fi
10402 
10403 
10404   test -n "$UNAME" && break
10405 done
10406 
10407     else
10408       # If it succeeded, then it was overridden by the user. We will use it
10409       # for the tool.
10410 
10411       # First remove it from the list of overridden variables, so we can test
10412       # for unknown variables in the end.
10413       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10414 
10415       # Check if the provided tool contains a complete path.
10416       tool_specified="$UNAME"
10417       tool_basename="${tool_specified##*/}"
10418       if test "x$tool_basename" = "x$tool_specified"; then
10419         # A command without a complete path is provided, search $PATH.
10420         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
10421 $as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
10422         # Extract the first word of "$tool_basename", so it can be a program name with args.
10423 set dummy $tool_basename; ac_word=$2
10424 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10425 $as_echo_n "checking for $ac_word... " >&6; }
10426 if ${ac_cv_path_UNAME+:} false; then :
10427   $as_echo_n "(cached) " >&6
10428 else
10429   case $UNAME in
10430   [\\/]* | ?:[\\/]*)
10431   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10432   ;;
10433   *)
10434   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10435 for as_dir in $PATH
10436 do
10437   IFS=$as_save_IFS
10438   test -z "$as_dir" && as_dir=.
10439     for ac_exec_ext in '' $ac_executable_extensions; do
10440   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10441     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10442     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10443     break 2
10444   fi
10445 done
10446   done
10447 IFS=$as_save_IFS
10448 
10449   ;;
10450 esac
10451 fi
10452 UNAME=$ac_cv_path_UNAME
10453 if test -n "$UNAME"; then
10454   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10455 $as_echo "$UNAME" >&6; }
10456 else
10457   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10458 $as_echo "no" >&6; }
10459 fi
10460 
10461 
10462         if test "x$UNAME" = x; then
10463           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10464         fi
10465       else
10466         # Otherwise we believe it is a complete path. Use it as it is.
10467         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
10468 $as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
10469         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
10470 $as_echo_n "checking for UNAME... " >&6; }
10471         if test ! -x "$tool_specified"; then
10472           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10473 $as_echo "not found" >&6; }
10474           as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
10475         fi
10476         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10477 $as_echo "$tool_specified" >&6; }
10478       fi
10479     fi
10480   fi
10481 
10482 
10483 
10484   if test "x$UNAME" = x; then
10485     as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
10486   fi
10487 
10488 
10489 
10490 
10491 
10492   # Publish this variable in the help.
10493 
10494 
10495   if test "x$UNIQ" = x; then
10496     # The variable is not set by user, try to locate tool using the code snippet
10497     for ac_prog in uniq
10498 do
10499   # Extract the first word of "$ac_prog", so it can be a program name with args.
10500 set dummy $ac_prog; ac_word=$2
10501 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10502 $as_echo_n "checking for $ac_word... " >&6; }
10503 if ${ac_cv_path_UNIQ+:} false; then :
10504   $as_echo_n "(cached) " >&6
10505 else
10506   case $UNIQ in
10507   [\\/]* | ?:[\\/]*)
10508   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10509   ;;
10510   *)
10511   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10512 for as_dir in $PATH
10513 do
10514   IFS=$as_save_IFS
10515   test -z "$as_dir" && as_dir=.
10516     for ac_exec_ext in '' $ac_executable_extensions; do
10517   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10518     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10519     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10520     break 2
10521   fi
10522 done
10523   done
10524 IFS=$as_save_IFS
10525 
10526   ;;
10527 esac
10528 fi
10529 UNIQ=$ac_cv_path_UNIQ
10530 if test -n "$UNIQ"; then
10531   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10532 $as_echo "$UNIQ" >&6; }
10533 else
10534   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10535 $as_echo "no" >&6; }
10536 fi
10537 
10538 
10539   test -n "$UNIQ" && break
10540 done
10541 
10542   else
10543     # The variable is set, but is it from the command line or the environment?
10544 
10545     # Try to remove the string !UNIQ! from our list.
10546     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
10547     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10548       # If it failed, the variable was not from the command line. Ignore it,
10549       # but warn the user (except for BASH, which is always set by the calling BASH).
10550       if test "xUNIQ" != xBASH; then
10551         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
10552 $as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
10553       fi
10554       # Try to locate tool using the code snippet
10555       for ac_prog in uniq
10556 do
10557   # Extract the first word of "$ac_prog", so it can be a program name with args.
10558 set dummy $ac_prog; ac_word=$2
10559 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10560 $as_echo_n "checking for $ac_word... " >&6; }
10561 if ${ac_cv_path_UNIQ+:} false; then :
10562   $as_echo_n "(cached) " >&6
10563 else
10564   case $UNIQ in
10565   [\\/]* | ?:[\\/]*)
10566   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10567   ;;
10568   *)
10569   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10570 for as_dir in $PATH
10571 do
10572   IFS=$as_save_IFS
10573   test -z "$as_dir" && as_dir=.
10574     for ac_exec_ext in '' $ac_executable_extensions; do
10575   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10576     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10577     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10578     break 2
10579   fi
10580 done
10581   done
10582 IFS=$as_save_IFS
10583 
10584   ;;
10585 esac
10586 fi
10587 UNIQ=$ac_cv_path_UNIQ
10588 if test -n "$UNIQ"; then
10589   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10590 $as_echo "$UNIQ" >&6; }
10591 else
10592   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10593 $as_echo "no" >&6; }
10594 fi
10595 
10596 
10597   test -n "$UNIQ" && break
10598 done
10599 
10600     else
10601       # If it succeeded, then it was overridden by the user. We will use it
10602       # for the tool.
10603 
10604       # First remove it from the list of overridden variables, so we can test
10605       # for unknown variables in the end.
10606       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10607 
10608       # Check if the provided tool contains a complete path.
10609       tool_specified="$UNIQ"
10610       tool_basename="${tool_specified##*/}"
10611       if test "x$tool_basename" = "x$tool_specified"; then
10612         # A command without a complete path is provided, search $PATH.
10613         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
10614 $as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
10615         # Extract the first word of "$tool_basename", so it can be a program name with args.
10616 set dummy $tool_basename; ac_word=$2
10617 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10618 $as_echo_n "checking for $ac_word... " >&6; }
10619 if ${ac_cv_path_UNIQ+:} false; then :
10620   $as_echo_n "(cached) " >&6
10621 else
10622   case $UNIQ in
10623   [\\/]* | ?:[\\/]*)
10624   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10625   ;;
10626   *)
10627   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10628 for as_dir in $PATH
10629 do
10630   IFS=$as_save_IFS
10631   test -z "$as_dir" && as_dir=.
10632     for ac_exec_ext in '' $ac_executable_extensions; do
10633   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10634     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10635     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10636     break 2
10637   fi
10638 done
10639   done
10640 IFS=$as_save_IFS
10641 
10642   ;;
10643 esac
10644 fi
10645 UNIQ=$ac_cv_path_UNIQ
10646 if test -n "$UNIQ"; then
10647   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10648 $as_echo "$UNIQ" >&6; }
10649 else
10650   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10651 $as_echo "no" >&6; }
10652 fi
10653 
10654 
10655         if test "x$UNIQ" = x; then
10656           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10657         fi
10658       else
10659         # Otherwise we believe it is a complete path. Use it as it is.
10660         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
10661 $as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
10662         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
10663 $as_echo_n "checking for UNIQ... " >&6; }
10664         if test ! -x "$tool_specified"; then
10665           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10666 $as_echo "not found" >&6; }
10667           as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
10668         fi
10669         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10670 $as_echo "$tool_specified" >&6; }
10671       fi
10672     fi
10673   fi
10674 
10675 
10676 
10677   if test "x$UNIQ" = x; then
10678     as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
10679   fi
10680 
10681 
10682 
10683 
10684 
10685   # Publish this variable in the help.
10686 
10687 
10688   if test "x$WC" = x; then
10689     # The variable is not set by user, try to locate tool using the code snippet
10690     for ac_prog in wc
10691 do
10692   # Extract the first word of "$ac_prog", so it can be a program name with args.
10693 set dummy $ac_prog; ac_word=$2
10694 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10695 $as_echo_n "checking for $ac_word... " >&6; }
10696 if ${ac_cv_path_WC+:} false; then :
10697   $as_echo_n "(cached) " >&6
10698 else
10699   case $WC in
10700   [\\/]* | ?:[\\/]*)
10701   ac_cv_path_WC="$WC" # Let the user override the test with a path.
10702   ;;
10703   *)
10704   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10705 for as_dir in $PATH
10706 do
10707   IFS=$as_save_IFS
10708   test -z "$as_dir" && as_dir=.
10709     for ac_exec_ext in '' $ac_executable_extensions; do
10710   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10711     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10712     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10713     break 2
10714   fi
10715 done
10716   done
10717 IFS=$as_save_IFS
10718 
10719   ;;
10720 esac
10721 fi
10722 WC=$ac_cv_path_WC
10723 if test -n "$WC"; then
10724   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10725 $as_echo "$WC" >&6; }
10726 else
10727   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10728 $as_echo "no" >&6; }
10729 fi
10730 
10731 
10732   test -n "$WC" && break
10733 done
10734 
10735   else
10736     # The variable is set, but is it from the command line or the environment?
10737 
10738     # Try to remove the string !WC! from our list.
10739     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
10740     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10741       # If it failed, the variable was not from the command line. Ignore it,
10742       # but warn the user (except for BASH, which is always set by the calling BASH).
10743       if test "xWC" != xBASH; then
10744         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
10745 $as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
10746       fi
10747       # Try to locate tool using the code snippet
10748       for ac_prog in wc
10749 do
10750   # Extract the first word of "$ac_prog", so it can be a program name with args.
10751 set dummy $ac_prog; ac_word=$2
10752 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10753 $as_echo_n "checking for $ac_word... " >&6; }
10754 if ${ac_cv_path_WC+:} false; then :
10755   $as_echo_n "(cached) " >&6
10756 else
10757   case $WC in
10758   [\\/]* | ?:[\\/]*)
10759   ac_cv_path_WC="$WC" # Let the user override the test with a path.
10760   ;;
10761   *)
10762   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10763 for as_dir in $PATH
10764 do
10765   IFS=$as_save_IFS
10766   test -z "$as_dir" && as_dir=.
10767     for ac_exec_ext in '' $ac_executable_extensions; do
10768   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10769     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10770     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10771     break 2
10772   fi
10773 done
10774   done
10775 IFS=$as_save_IFS
10776 
10777   ;;
10778 esac
10779 fi
10780 WC=$ac_cv_path_WC
10781 if test -n "$WC"; then
10782   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10783 $as_echo "$WC" >&6; }
10784 else
10785   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10786 $as_echo "no" >&6; }
10787 fi
10788 
10789 
10790   test -n "$WC" && break
10791 done
10792 
10793     else
10794       # If it succeeded, then it was overridden by the user. We will use it
10795       # for the tool.
10796 
10797       # First remove it from the list of overridden variables, so we can test
10798       # for unknown variables in the end.
10799       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10800 
10801       # Check if the provided tool contains a complete path.
10802       tool_specified="$WC"
10803       tool_basename="${tool_specified##*/}"
10804       if test "x$tool_basename" = "x$tool_specified"; then
10805         # A command without a complete path is provided, search $PATH.
10806         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
10807 $as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
10808         # Extract the first word of "$tool_basename", so it can be a program name with args.
10809 set dummy $tool_basename; ac_word=$2
10810 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10811 $as_echo_n "checking for $ac_word... " >&6; }
10812 if ${ac_cv_path_WC+:} false; then :
10813   $as_echo_n "(cached) " >&6
10814 else
10815   case $WC in
10816   [\\/]* | ?:[\\/]*)
10817   ac_cv_path_WC="$WC" # Let the user override the test with a path.
10818   ;;
10819   *)
10820   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10821 for as_dir in $PATH
10822 do
10823   IFS=$as_save_IFS
10824   test -z "$as_dir" && as_dir=.
10825     for ac_exec_ext in '' $ac_executable_extensions; do
10826   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10827     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10828     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10829     break 2
10830   fi
10831 done
10832   done
10833 IFS=$as_save_IFS
10834 
10835   ;;
10836 esac
10837 fi
10838 WC=$ac_cv_path_WC
10839 if test -n "$WC"; then
10840   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10841 $as_echo "$WC" >&6; }
10842 else
10843   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10844 $as_echo "no" >&6; }
10845 fi
10846 
10847 
10848         if test "x$WC" = x; then
10849           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10850         fi
10851       else
10852         # Otherwise we believe it is a complete path. Use it as it is.
10853         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
10854 $as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
10855         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
10856 $as_echo_n "checking for WC... " >&6; }
10857         if test ! -x "$tool_specified"; then
10858           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10859 $as_echo "not found" >&6; }
10860           as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
10861         fi
10862         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10863 $as_echo "$tool_specified" >&6; }
10864       fi
10865     fi
10866   fi
10867 
10868 
10869 
10870   if test "x$WC" = x; then
10871     as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
10872   fi
10873 
10874 
10875 
10876 
10877 
10878   # Publish this variable in the help.
10879 
10880 
10881   if test "x$WHICH" = x; then
10882     # The variable is not set by user, try to locate tool using the code snippet
10883     for ac_prog in which
10884 do
10885   # Extract the first word of "$ac_prog", so it can be a program name with args.
10886 set dummy $ac_prog; ac_word=$2
10887 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10888 $as_echo_n "checking for $ac_word... " >&6; }
10889 if ${ac_cv_path_WHICH+:} false; then :
10890   $as_echo_n "(cached) " >&6
10891 else
10892   case $WHICH in
10893   [\\/]* | ?:[\\/]*)
10894   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
10895   ;;
10896   *)
10897   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10898 for as_dir in $PATH
10899 do
10900   IFS=$as_save_IFS
10901   test -z "$as_dir" && as_dir=.
10902     for ac_exec_ext in '' $ac_executable_extensions; do
10903   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10904     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
10905     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10906     break 2
10907   fi
10908 done
10909   done
10910 IFS=$as_save_IFS
10911 
10912   ;;
10913 esac
10914 fi
10915 WHICH=$ac_cv_path_WHICH
10916 if test -n "$WHICH"; then
10917   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
10918 $as_echo "$WHICH" >&6; }
10919 else
10920   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10921 $as_echo "no" >&6; }
10922 fi
10923 
10924 
10925   test -n "$WHICH" && break
10926 done
10927 
10928   else
10929     # The variable is set, but is it from the command line or the environment?
10930 
10931     # Try to remove the string !WHICH! from our list.
10932     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
10933     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10934       # If it failed, the variable was not from the command line. Ignore it,
10935       # but warn the user (except for BASH, which is always set by the calling BASH).
10936       if test "xWHICH" != xBASH; then
10937         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
10938 $as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
10939       fi
10940       # Try to locate tool using the code snippet
10941       for ac_prog in which
10942 do
10943   # Extract the first word of "$ac_prog", so it can be a program name with args.
10944 set dummy $ac_prog; ac_word=$2
10945 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10946 $as_echo_n "checking for $ac_word... " >&6; }
10947 if ${ac_cv_path_WHICH+:} false; then :
10948   $as_echo_n "(cached) " >&6
10949 else
10950   case $WHICH in
10951   [\\/]* | ?:[\\/]*)
10952   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
10953   ;;
10954   *)
10955   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10956 for as_dir in $PATH
10957 do
10958   IFS=$as_save_IFS
10959   test -z "$as_dir" && as_dir=.
10960     for ac_exec_ext in '' $ac_executable_extensions; do
10961   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10962     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
10963     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10964     break 2
10965   fi
10966 done
10967   done
10968 IFS=$as_save_IFS
10969 
10970   ;;
10971 esac
10972 fi
10973 WHICH=$ac_cv_path_WHICH
10974 if test -n "$WHICH"; then
10975   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
10976 $as_echo "$WHICH" >&6; }
10977 else
10978   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10979 $as_echo "no" >&6; }
10980 fi
10981 
10982 
10983   test -n "$WHICH" && break
10984 done
10985 
10986     else
10987       # If it succeeded, then it was overridden by the user. We will use it
10988       # for the tool.
10989 
10990       # First remove it from the list of overridden variables, so we can test
10991       # for unknown variables in the end.
10992       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10993 
10994       # Check if the provided tool contains a complete path.
10995       tool_specified="$WHICH"
10996       tool_basename="${tool_specified##*/}"
10997       if test "x$tool_basename" = "x$tool_specified"; then
10998         # A command without a complete path is provided, search $PATH.
10999         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
11000 $as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
11001         # Extract the first word of "$tool_basename", so it can be a program name with args.
11002 set dummy $tool_basename; ac_word=$2
11003 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11004 $as_echo_n "checking for $ac_word... " >&6; }
11005 if ${ac_cv_path_WHICH+:} false; then :
11006   $as_echo_n "(cached) " >&6
11007 else
11008   case $WHICH in
11009   [\\/]* | ?:[\\/]*)
11010   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11011   ;;
11012   *)
11013   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11014 for as_dir in $PATH
11015 do
11016   IFS=$as_save_IFS
11017   test -z "$as_dir" && as_dir=.
11018     for ac_exec_ext in '' $ac_executable_extensions; do
11019   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11020     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11021     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11022     break 2
11023   fi
11024 done
11025   done
11026 IFS=$as_save_IFS
11027 
11028   ;;
11029 esac
11030 fi
11031 WHICH=$ac_cv_path_WHICH
11032 if test -n "$WHICH"; then
11033   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11034 $as_echo "$WHICH" >&6; }
11035 else
11036   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11037 $as_echo "no" >&6; }
11038 fi
11039 
11040 
11041         if test "x$WHICH" = x; then
11042           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11043         fi
11044       else
11045         # Otherwise we believe it is a complete path. Use it as it is.
11046         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
11047 $as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
11048         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
11049 $as_echo_n "checking for WHICH... " >&6; }
11050         if test ! -x "$tool_specified"; then
11051           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11052 $as_echo "not found" >&6; }
11053           as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
11054         fi
11055         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11056 $as_echo "$tool_specified" >&6; }
11057       fi
11058     fi
11059   fi
11060 
11061 
11062 
11063   if test "x$WHICH" = x; then
11064     as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
11065   fi
11066 
11067 
11068 
11069 
11070 
11071   # Publish this variable in the help.
11072 
11073 
11074   if test "x$XARGS" = x; then
11075     # The variable is not set by user, try to locate tool using the code snippet
11076     for ac_prog in xargs
11077 do
11078   # Extract the first word of "$ac_prog", so it can be a program name with args.
11079 set dummy $ac_prog; ac_word=$2
11080 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11081 $as_echo_n "checking for $ac_word... " >&6; }
11082 if ${ac_cv_path_XARGS+:} false; then :
11083   $as_echo_n "(cached) " >&6
11084 else
11085   case $XARGS in
11086   [\\/]* | ?:[\\/]*)
11087   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11088   ;;
11089   *)
11090   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11091 for as_dir in $PATH
11092 do
11093   IFS=$as_save_IFS
11094   test -z "$as_dir" && as_dir=.
11095     for ac_exec_ext in '' $ac_executable_extensions; do
11096   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11097     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11098     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11099     break 2
11100   fi
11101 done
11102   done
11103 IFS=$as_save_IFS
11104 
11105   ;;
11106 esac
11107 fi
11108 XARGS=$ac_cv_path_XARGS
11109 if test -n "$XARGS"; then
11110   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11111 $as_echo "$XARGS" >&6; }
11112 else
11113   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11114 $as_echo "no" >&6; }
11115 fi
11116 
11117 
11118   test -n "$XARGS" && break
11119 done
11120 
11121   else
11122     # The variable is set, but is it from the command line or the environment?
11123 
11124     # Try to remove the string !XARGS! from our list.
11125     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
11126     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11127       # If it failed, the variable was not from the command line. Ignore it,
11128       # but warn the user (except for BASH, which is always set by the calling BASH).
11129       if test "xXARGS" != xBASH; then
11130         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
11131 $as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
11132       fi
11133       # Try to locate tool using the code snippet
11134       for ac_prog in xargs
11135 do
11136   # Extract the first word of "$ac_prog", so it can be a program name with args.
11137 set dummy $ac_prog; ac_word=$2
11138 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11139 $as_echo_n "checking for $ac_word... " >&6; }
11140 if ${ac_cv_path_XARGS+:} false; then :
11141   $as_echo_n "(cached) " >&6
11142 else
11143   case $XARGS in
11144   [\\/]* | ?:[\\/]*)
11145   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11146   ;;
11147   *)
11148   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11149 for as_dir in $PATH
11150 do
11151   IFS=$as_save_IFS
11152   test -z "$as_dir" && as_dir=.
11153     for ac_exec_ext in '' $ac_executable_extensions; do
11154   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11155     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11156     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11157     break 2
11158   fi
11159 done
11160   done
11161 IFS=$as_save_IFS
11162 
11163   ;;
11164 esac
11165 fi
11166 XARGS=$ac_cv_path_XARGS
11167 if test -n "$XARGS"; then
11168   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11169 $as_echo "$XARGS" >&6; }
11170 else
11171   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11172 $as_echo "no" >&6; }
11173 fi
11174 
11175 
11176   test -n "$XARGS" && break
11177 done
11178 
11179     else
11180       # If it succeeded, then it was overridden by the user. We will use it
11181       # for the tool.
11182 
11183       # First remove it from the list of overridden variables, so we can test
11184       # for unknown variables in the end.
11185       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11186 
11187       # Check if the provided tool contains a complete path.
11188       tool_specified="$XARGS"
11189       tool_basename="${tool_specified##*/}"
11190       if test "x$tool_basename" = "x$tool_specified"; then
11191         # A command without a complete path is provided, search $PATH.
11192         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
11193 $as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
11194         # Extract the first word of "$tool_basename", so it can be a program name with args.
11195 set dummy $tool_basename; ac_word=$2
11196 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11197 $as_echo_n "checking for $ac_word... " >&6; }
11198 if ${ac_cv_path_XARGS+:} false; then :
11199   $as_echo_n "(cached) " >&6
11200 else
11201   case $XARGS in
11202   [\\/]* | ?:[\\/]*)
11203   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11204   ;;
11205   *)
11206   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11207 for as_dir in $PATH
11208 do
11209   IFS=$as_save_IFS
11210   test -z "$as_dir" && as_dir=.
11211     for ac_exec_ext in '' $ac_executable_extensions; do
11212   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11213     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11214     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11215     break 2
11216   fi
11217 done
11218   done
11219 IFS=$as_save_IFS
11220 
11221   ;;
11222 esac
11223 fi
11224 XARGS=$ac_cv_path_XARGS
11225 if test -n "$XARGS"; then
11226   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11227 $as_echo "$XARGS" >&6; }
11228 else
11229   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11230 $as_echo "no" >&6; }
11231 fi
11232 
11233 
11234         if test "x$XARGS" = x; then
11235           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11236         fi
11237       else
11238         # Otherwise we believe it is a complete path. Use it as it is.
11239         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
11240 $as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
11241         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
11242 $as_echo_n "checking for XARGS... " >&6; }
11243         if test ! -x "$tool_specified"; then
11244           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11245 $as_echo "not found" >&6; }
11246           as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
11247         fi
11248         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11249 $as_echo "$tool_specified" >&6; }
11250       fi
11251     fi
11252   fi
11253 
11254 
11255 
11256   if test "x$XARGS" = x; then
11257     as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
11258   fi
11259 
11260 
11261 
11262   # Then required tools that require some special treatment.
11263 
11264 
11265   # Publish this variable in the help.
11266 
11267 
11268   if test "x$AWK" = x; then
11269     # The variable is not set by user, try to locate tool using the code snippet
11270     for ac_prog in gawk mawk nawk awk
11271 do
11272   # Extract the first word of "$ac_prog", so it can be a program name with args.
11273 set dummy $ac_prog; ac_word=$2
11274 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11275 $as_echo_n "checking for $ac_word... " >&6; }
11276 if ${ac_cv_prog_AWK+:} false; then :
11277   $as_echo_n "(cached) " >&6
11278 else
11279   if test -n "$AWK"; then
11280   ac_cv_prog_AWK="$AWK" # Let the user override the test.
11281 else
11282 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11283 for as_dir in $PATH
11284 do
11285   IFS=$as_save_IFS
11286   test -z "$as_dir" && as_dir=.
11287     for ac_exec_ext in '' $ac_executable_extensions; do
11288   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11289     ac_cv_prog_AWK="$ac_prog"
11290     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11291     break 2
11292   fi
11293 done
11294   done
11295 IFS=$as_save_IFS
11296 
11297 fi
11298 fi
11299 AWK=$ac_cv_prog_AWK
11300 if test -n "$AWK"; then
11301   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11302 $as_echo "$AWK" >&6; }
11303 else
11304   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11305 $as_echo "no" >&6; }
11306 fi
11307 
11308 
11309   test -n "$AWK" && break
11310 done
11311 
11312   else
11313     # The variable is set, but is it from the command line or the environment?
11314 
11315     # Try to remove the string !AWK! from our list.
11316     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
11317     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11318       # If it failed, the variable was not from the command line. Ignore it,
11319       # but warn the user (except for BASH, which is always set by the calling BASH).
11320       if test "xAWK" != xBASH; then
11321         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
11322 $as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
11323       fi
11324       # Try to locate tool using the code snippet
11325       for ac_prog in gawk mawk nawk awk
11326 do
11327   # Extract the first word of "$ac_prog", so it can be a program name with args.
11328 set dummy $ac_prog; ac_word=$2
11329 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11330 $as_echo_n "checking for $ac_word... " >&6; }
11331 if ${ac_cv_prog_AWK+:} false; then :
11332   $as_echo_n "(cached) " >&6
11333 else
11334   if test -n "$AWK"; then
11335   ac_cv_prog_AWK="$AWK" # Let the user override the test.
11336 else
11337 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11338 for as_dir in $PATH
11339 do
11340   IFS=$as_save_IFS
11341   test -z "$as_dir" && as_dir=.
11342     for ac_exec_ext in '' $ac_executable_extensions; do
11343   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11344     ac_cv_prog_AWK="$ac_prog"
11345     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11346     break 2
11347   fi
11348 done
11349   done
11350 IFS=$as_save_IFS
11351 
11352 fi
11353 fi
11354 AWK=$ac_cv_prog_AWK
11355 if test -n "$AWK"; then
11356   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11357 $as_echo "$AWK" >&6; }
11358 else
11359   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11360 $as_echo "no" >&6; }
11361 fi
11362 
11363 
11364   test -n "$AWK" && break
11365 done
11366 
11367     else
11368       # If it succeeded, then it was overridden by the user. We will use it
11369       # for the tool.
11370 
11371       # First remove it from the list of overridden variables, so we can test
11372       # for unknown variables in the end.
11373       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11374 
11375       # Check if the provided tool contains a complete path.
11376       tool_specified="$AWK"
11377       tool_basename="${tool_specified##*/}"
11378       if test "x$tool_basename" = "x$tool_specified"; then
11379         # A command without a complete path is provided, search $PATH.
11380         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
11381 $as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
11382         # Extract the first word of "$tool_basename", so it can be a program name with args.
11383 set dummy $tool_basename; ac_word=$2
11384 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11385 $as_echo_n "checking for $ac_word... " >&6; }
11386 if ${ac_cv_path_AWK+:} false; then :
11387   $as_echo_n "(cached) " >&6
11388 else
11389   case $AWK in
11390   [\\/]* | ?:[\\/]*)
11391   ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
11392   ;;
11393   *)
11394   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11395 for as_dir in $PATH
11396 do
11397   IFS=$as_save_IFS
11398   test -z "$as_dir" && as_dir=.
11399     for ac_exec_ext in '' $ac_executable_extensions; do
11400   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11401     ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
11402     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11403     break 2
11404   fi
11405 done
11406   done
11407 IFS=$as_save_IFS
11408 
11409   ;;
11410 esac
11411 fi
11412 AWK=$ac_cv_path_AWK
11413 if test -n "$AWK"; then
11414   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11415 $as_echo "$AWK" >&6; }
11416 else
11417   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11418 $as_echo "no" >&6; }
11419 fi
11420 
11421 
11422         if test "x$AWK" = x; then
11423           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11424         fi
11425       else
11426         # Otherwise we believe it is a complete path. Use it as it is.
11427         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
11428 $as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
11429         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
11430 $as_echo_n "checking for AWK... " >&6; }
11431         if test ! -x "$tool_specified"; then
11432           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11433 $as_echo "not found" >&6; }
11434           as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
11435         fi
11436         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11437 $as_echo "$tool_specified" >&6; }
11438       fi
11439     fi
11440   fi
11441 
11442 
11443   if test "x$AWK" = x; then
11444     as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
11445   fi
11446 
11447 
11448 
11449 
11450   # Publish this variable in the help.
11451 
11452 
11453   if test "x$GREP" = x; then
11454     # The variable is not set by user, try to locate tool using the code snippet
11455     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11456 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11457 if ${ac_cv_path_GREP+:} false; then :
11458   $as_echo_n "(cached) " >&6
11459 else
11460   if test -z "$GREP"; then
11461   ac_path_GREP_found=false
11462   # Loop through the user's path and test for each of PROGNAME-LIST
11463   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11464 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11465 do
11466   IFS=$as_save_IFS
11467   test -z "$as_dir" && as_dir=.
11468     for ac_prog in grep ggrep; do
11469     for ac_exec_ext in '' $ac_executable_extensions; do
11470       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11471       as_fn_executable_p "$ac_path_GREP" || continue
11472 # Check for GNU ac_path_GREP and select it if it is found.
11473   # Check for GNU $ac_path_GREP
11474 case `"$ac_path_GREP" --version 2>&1` in
11475 *GNU*)
11476   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11477 *)
11478   ac_count=0
11479   $as_echo_n 0123456789 >"conftest.in"
11480   while :
11481   do
11482     cat "conftest.in" "conftest.in" >"conftest.tmp"
11483     mv "conftest.tmp" "conftest.in"
11484     cp "conftest.in" "conftest.nl"
11485     $as_echo 'GREP' >> "conftest.nl"
11486     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11487     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11488     as_fn_arith $ac_count + 1 && ac_count=$as_val
11489     if test $ac_count -gt ${ac_path_GREP_max-0}; then
11490       # Best one so far, save it but keep looking for a better one
11491       ac_cv_path_GREP="$ac_path_GREP"
11492       ac_path_GREP_max=$ac_count
11493     fi
11494     # 10*(2^10) chars as input seems more than enough
11495     test $ac_count -gt 10 && break
11496   done
11497   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11498 esac
11499 
11500       $ac_path_GREP_found && break 3
11501     done
11502   done
11503   done
11504 IFS=$as_save_IFS
11505   if test -z "$ac_cv_path_GREP"; then
11506     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11507   fi
11508 else
11509   ac_cv_path_GREP=$GREP
11510 fi
11511 
11512 fi
11513 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11514 $as_echo "$ac_cv_path_GREP" >&6; }
11515  GREP="$ac_cv_path_GREP"
11516 
11517 
11518   else
11519     # The variable is set, but is it from the command line or the environment?
11520 
11521     # Try to remove the string !GREP! from our list.
11522     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
11523     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11524       # If it failed, the variable was not from the command line. Ignore it,
11525       # but warn the user (except for BASH, which is always set by the calling BASH).
11526       if test "xGREP" != xBASH; then
11527         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
11528 $as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
11529       fi
11530       # Try to locate tool using the code snippet
11531       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11532 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11533 if ${ac_cv_path_GREP+:} false; then :
11534   $as_echo_n "(cached) " >&6
11535 else
11536   if test -z "$GREP"; then
11537   ac_path_GREP_found=false
11538   # Loop through the user's path and test for each of PROGNAME-LIST
11539   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11540 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11541 do
11542   IFS=$as_save_IFS
11543   test -z "$as_dir" && as_dir=.
11544     for ac_prog in grep ggrep; do
11545     for ac_exec_ext in '' $ac_executable_extensions; do
11546       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11547       as_fn_executable_p "$ac_path_GREP" || continue
11548 # Check for GNU ac_path_GREP and select it if it is found.
11549   # Check for GNU $ac_path_GREP
11550 case `"$ac_path_GREP" --version 2>&1` in
11551 *GNU*)
11552   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11553 *)
11554   ac_count=0
11555   $as_echo_n 0123456789 >"conftest.in"
11556   while :
11557   do
11558     cat "conftest.in" "conftest.in" >"conftest.tmp"
11559     mv "conftest.tmp" "conftest.in"
11560     cp "conftest.in" "conftest.nl"
11561     $as_echo 'GREP' >> "conftest.nl"
11562     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11563     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11564     as_fn_arith $ac_count + 1 && ac_count=$as_val
11565     if test $ac_count -gt ${ac_path_GREP_max-0}; then
11566       # Best one so far, save it but keep looking for a better one
11567       ac_cv_path_GREP="$ac_path_GREP"
11568       ac_path_GREP_max=$ac_count
11569     fi
11570     # 10*(2^10) chars as input seems more than enough
11571     test $ac_count -gt 10 && break
11572   done
11573   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11574 esac
11575 
11576       $ac_path_GREP_found && break 3
11577     done
11578   done
11579   done
11580 IFS=$as_save_IFS
11581   if test -z "$ac_cv_path_GREP"; then
11582     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11583   fi
11584 else
11585   ac_cv_path_GREP=$GREP
11586 fi
11587 
11588 fi
11589 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11590 $as_echo "$ac_cv_path_GREP" >&6; }
11591  GREP="$ac_cv_path_GREP"
11592 
11593 
11594     else
11595       # If it succeeded, then it was overridden by the user. We will use it
11596       # for the tool.
11597 
11598       # First remove it from the list of overridden variables, so we can test
11599       # for unknown variables in the end.
11600       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11601 
11602       # Check if the provided tool contains a complete path.
11603       tool_specified="$GREP"
11604       tool_basename="${tool_specified##*/}"
11605       if test "x$tool_basename" = "x$tool_specified"; then
11606         # A command without a complete path is provided, search $PATH.
11607         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
11608 $as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
11609         # Extract the first word of "$tool_basename", so it can be a program name with args.
11610 set dummy $tool_basename; ac_word=$2
11611 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11612 $as_echo_n "checking for $ac_word... " >&6; }
11613 if ${ac_cv_path_GREP+:} false; then :
11614   $as_echo_n "(cached) " >&6
11615 else
11616   case $GREP in
11617   [\\/]* | ?:[\\/]*)
11618   ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
11619   ;;
11620   *)
11621   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11622 for as_dir in $PATH
11623 do
11624   IFS=$as_save_IFS
11625   test -z "$as_dir" && as_dir=.
11626     for ac_exec_ext in '' $ac_executable_extensions; do
11627   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11628     ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
11629     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11630     break 2
11631   fi
11632 done
11633   done
11634 IFS=$as_save_IFS
11635 
11636   ;;
11637 esac
11638 fi
11639 GREP=$ac_cv_path_GREP
11640 if test -n "$GREP"; then
11641   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
11642 $as_echo "$GREP" >&6; }
11643 else
11644   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11645 $as_echo "no" >&6; }
11646 fi
11647 
11648 
11649         if test "x$GREP" = x; then
11650           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11651         fi
11652       else
11653         # Otherwise we believe it is a complete path. Use it as it is.
11654         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
11655 $as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
11656         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
11657 $as_echo_n "checking for GREP... " >&6; }
11658         if test ! -x "$tool_specified"; then
11659           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11660 $as_echo "not found" >&6; }
11661           as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
11662         fi
11663         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11664 $as_echo "$tool_specified" >&6; }
11665       fi
11666     fi
11667   fi
11668 
11669 
11670   if test "x$GREP" = x; then
11671     as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
11672   fi
11673 
11674 
11675 
11676 
11677   # Publish this variable in the help.
11678 
11679 
11680   if test "x$EGREP" = x; then
11681     # The variable is not set by user, try to locate tool using the code snippet
11682     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11683 $as_echo_n "checking for egrep... " >&6; }
11684 if ${ac_cv_path_EGREP+:} false; then :
11685   $as_echo_n "(cached) " >&6
11686 else
11687   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11688    then ac_cv_path_EGREP="$GREP -E"
11689    else
11690      if test -z "$EGREP"; then
11691   ac_path_EGREP_found=false
11692   # Loop through the user's path and test for each of PROGNAME-LIST
11693   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11694 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11695 do
11696   IFS=$as_save_IFS
11697   test -z "$as_dir" && as_dir=.
11698     for ac_prog in egrep; do
11699     for ac_exec_ext in '' $ac_executable_extensions; do
11700       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11701       as_fn_executable_p "$ac_path_EGREP" || continue
11702 # Check for GNU ac_path_EGREP and select it if it is found.
11703   # Check for GNU $ac_path_EGREP
11704 case `"$ac_path_EGREP" --version 2>&1` in
11705 *GNU*)
11706   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11707 *)
11708   ac_count=0
11709   $as_echo_n 0123456789 >"conftest.in"
11710   while :
11711   do
11712     cat "conftest.in" "conftest.in" >"conftest.tmp"
11713     mv "conftest.tmp" "conftest.in"
11714     cp "conftest.in" "conftest.nl"
11715     $as_echo 'EGREP' >> "conftest.nl"
11716     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11717     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11718     as_fn_arith $ac_count + 1 && ac_count=$as_val
11719     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11720       # Best one so far, save it but keep looking for a better one
11721       ac_cv_path_EGREP="$ac_path_EGREP"
11722       ac_path_EGREP_max=$ac_count
11723     fi
11724     # 10*(2^10) chars as input seems more than enough
11725     test $ac_count -gt 10 && break
11726   done
11727   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11728 esac
11729 
11730       $ac_path_EGREP_found && break 3
11731     done
11732   done
11733   done
11734 IFS=$as_save_IFS
11735   if test -z "$ac_cv_path_EGREP"; then
11736     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11737   fi
11738 else
11739   ac_cv_path_EGREP=$EGREP
11740 fi
11741 
11742    fi
11743 fi
11744 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11745 $as_echo "$ac_cv_path_EGREP" >&6; }
11746  EGREP="$ac_cv_path_EGREP"
11747 
11748 
11749   else
11750     # The variable is set, but is it from the command line or the environment?
11751 
11752     # Try to remove the string !EGREP! from our list.
11753     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
11754     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11755       # If it failed, the variable was not from the command line. Ignore it,
11756       # but warn the user (except for BASH, which is always set by the calling BASH).
11757       if test "xEGREP" != xBASH; then
11758         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
11759 $as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
11760       fi
11761       # Try to locate tool using the code snippet
11762       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11763 $as_echo_n "checking for egrep... " >&6; }
11764 if ${ac_cv_path_EGREP+:} false; then :
11765   $as_echo_n "(cached) " >&6
11766 else
11767   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11768    then ac_cv_path_EGREP="$GREP -E"
11769    else
11770      if test -z "$EGREP"; then
11771   ac_path_EGREP_found=false
11772   # Loop through the user's path and test for each of PROGNAME-LIST
11773   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11774 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11775 do
11776   IFS=$as_save_IFS
11777   test -z "$as_dir" && as_dir=.
11778     for ac_prog in egrep; do
11779     for ac_exec_ext in '' $ac_executable_extensions; do
11780       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11781       as_fn_executable_p "$ac_path_EGREP" || continue
11782 # Check for GNU ac_path_EGREP and select it if it is found.
11783   # Check for GNU $ac_path_EGREP
11784 case `"$ac_path_EGREP" --version 2>&1` in
11785 *GNU*)
11786   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11787 *)
11788   ac_count=0
11789   $as_echo_n 0123456789 >"conftest.in"
11790   while :
11791   do
11792     cat "conftest.in" "conftest.in" >"conftest.tmp"
11793     mv "conftest.tmp" "conftest.in"
11794     cp "conftest.in" "conftest.nl"
11795     $as_echo 'EGREP' >> "conftest.nl"
11796     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11797     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11798     as_fn_arith $ac_count + 1 && ac_count=$as_val
11799     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11800       # Best one so far, save it but keep looking for a better one
11801       ac_cv_path_EGREP="$ac_path_EGREP"
11802       ac_path_EGREP_max=$ac_count
11803     fi
11804     # 10*(2^10) chars as input seems more than enough
11805     test $ac_count -gt 10 && break
11806   done
11807   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11808 esac
11809 
11810       $ac_path_EGREP_found && break 3
11811     done
11812   done
11813   done
11814 IFS=$as_save_IFS
11815   if test -z "$ac_cv_path_EGREP"; then
11816     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11817   fi
11818 else
11819   ac_cv_path_EGREP=$EGREP
11820 fi
11821 
11822    fi
11823 fi
11824 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11825 $as_echo "$ac_cv_path_EGREP" >&6; }
11826  EGREP="$ac_cv_path_EGREP"
11827 
11828 
11829     else
11830       # If it succeeded, then it was overridden by the user. We will use it
11831       # for the tool.
11832 
11833       # First remove it from the list of overridden variables, so we can test
11834       # for unknown variables in the end.
11835       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11836 
11837       # Check if the provided tool contains a complete path.
11838       tool_specified="$EGREP"
11839       tool_basename="${tool_specified##*/}"
11840       if test "x$tool_basename" = "x$tool_specified"; then
11841         # A command without a complete path is provided, search $PATH.
11842         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
11843 $as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
11844         # Extract the first word of "$tool_basename", so it can be a program name with args.
11845 set dummy $tool_basename; ac_word=$2
11846 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11847 $as_echo_n "checking for $ac_word... " >&6; }
11848 if ${ac_cv_path_EGREP+:} false; then :
11849   $as_echo_n "(cached) " >&6
11850 else
11851   case $EGREP in
11852   [\\/]* | ?:[\\/]*)
11853   ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
11854   ;;
11855   *)
11856   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11857 for as_dir in $PATH
11858 do
11859   IFS=$as_save_IFS
11860   test -z "$as_dir" && as_dir=.
11861     for ac_exec_ext in '' $ac_executable_extensions; do
11862   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11863     ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
11864     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11865     break 2
11866   fi
11867 done
11868   done
11869 IFS=$as_save_IFS
11870 
11871   ;;
11872 esac
11873 fi
11874 EGREP=$ac_cv_path_EGREP
11875 if test -n "$EGREP"; then
11876   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
11877 $as_echo "$EGREP" >&6; }
11878 else
11879   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11880 $as_echo "no" >&6; }
11881 fi
11882 
11883 
11884         if test "x$EGREP" = x; then
11885           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11886         fi
11887       else
11888         # Otherwise we believe it is a complete path. Use it as it is.
11889         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
11890 $as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
11891         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
11892 $as_echo_n "checking for EGREP... " >&6; }
11893         if test ! -x "$tool_specified"; then
11894           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11895 $as_echo "not found" >&6; }
11896           as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
11897         fi
11898         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11899 $as_echo "$tool_specified" >&6; }
11900       fi
11901     fi
11902   fi
11903 
11904 
11905   if test "x$EGREP" = x; then
11906     as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
11907   fi
11908 
11909 
11910 
11911 
11912   # Publish this variable in the help.
11913 
11914 
11915   if test "x$FGREP" = x; then
11916     # The variable is not set by user, try to locate tool using the code snippet
11917     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
11918 $as_echo_n "checking for fgrep... " >&6; }
11919 if ${ac_cv_path_FGREP+:} false; then :
11920   $as_echo_n "(cached) " >&6
11921 else
11922   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
11923    then ac_cv_path_FGREP="$GREP -F"
11924    else
11925      if test -z "$FGREP"; then
11926   ac_path_FGREP_found=false
11927   # Loop through the user's path and test for each of PROGNAME-LIST
11928   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11929 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11930 do
11931   IFS=$as_save_IFS
11932   test -z "$as_dir" && as_dir=.
11933     for ac_prog in fgrep; do
11934     for ac_exec_ext in '' $ac_executable_extensions; do
11935       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
11936       as_fn_executable_p "$ac_path_FGREP" || continue
11937 # Check for GNU ac_path_FGREP and select it if it is found.
11938   # Check for GNU $ac_path_FGREP
11939 case `"$ac_path_FGREP" --version 2>&1` in
11940 *GNU*)
11941   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
11942 *)
11943   ac_count=0
11944   $as_echo_n 0123456789 >"conftest.in"
11945   while :
11946   do
11947     cat "conftest.in" "conftest.in" >"conftest.tmp"
11948     mv "conftest.tmp" "conftest.in"
11949     cp "conftest.in" "conftest.nl"
11950     $as_echo 'FGREP' >> "conftest.nl"
11951     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
11952     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11953     as_fn_arith $ac_count + 1 && ac_count=$as_val
11954     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
11955       # Best one so far, save it but keep looking for a better one
11956       ac_cv_path_FGREP="$ac_path_FGREP"
11957       ac_path_FGREP_max=$ac_count
11958     fi
11959     # 10*(2^10) chars as input seems more than enough
11960     test $ac_count -gt 10 && break
11961   done
11962   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11963 esac
11964 
11965       $ac_path_FGREP_found && break 3
11966     done
11967   done
11968   done
11969 IFS=$as_save_IFS
11970   if test -z "$ac_cv_path_FGREP"; then
11971     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11972   fi
11973 else
11974   ac_cv_path_FGREP=$FGREP
11975 fi
11976 
11977    fi
11978 fi
11979 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
11980 $as_echo "$ac_cv_path_FGREP" >&6; }
11981  FGREP="$ac_cv_path_FGREP"
11982 
11983 
11984   else
11985     # The variable is set, but is it from the command line or the environment?
11986 
11987     # Try to remove the string !FGREP! from our list.
11988     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
11989     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11990       # If it failed, the variable was not from the command line. Ignore it,
11991       # but warn the user (except for BASH, which is always set by the calling BASH).
11992       if test "xFGREP" != xBASH; then
11993         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
11994 $as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
11995       fi
11996       # Try to locate tool using the code snippet
11997       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
11998 $as_echo_n "checking for fgrep... " >&6; }
11999 if ${ac_cv_path_FGREP+:} false; then :
12000   $as_echo_n "(cached) " >&6
12001 else
12002   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12003    then ac_cv_path_FGREP="$GREP -F"
12004    else
12005      if test -z "$FGREP"; then
12006   ac_path_FGREP_found=false
12007   # Loop through the user's path and test for each of PROGNAME-LIST
12008   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12009 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12010 do
12011   IFS=$as_save_IFS
12012   test -z "$as_dir" && as_dir=.
12013     for ac_prog in fgrep; do
12014     for ac_exec_ext in '' $ac_executable_extensions; do
12015       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12016       as_fn_executable_p "$ac_path_FGREP" || continue
12017 # Check for GNU ac_path_FGREP and select it if it is found.
12018   # Check for GNU $ac_path_FGREP
12019 case `"$ac_path_FGREP" --version 2>&1` in
12020 *GNU*)
12021   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12022 *)
12023   ac_count=0
12024   $as_echo_n 0123456789 >"conftest.in"
12025   while :
12026   do
12027     cat "conftest.in" "conftest.in" >"conftest.tmp"
12028     mv "conftest.tmp" "conftest.in"
12029     cp "conftest.in" "conftest.nl"
12030     $as_echo 'FGREP' >> "conftest.nl"
12031     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12032     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12033     as_fn_arith $ac_count + 1 && ac_count=$as_val
12034     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12035       # Best one so far, save it but keep looking for a better one
12036       ac_cv_path_FGREP="$ac_path_FGREP"
12037       ac_path_FGREP_max=$ac_count
12038     fi
12039     # 10*(2^10) chars as input seems more than enough
12040     test $ac_count -gt 10 && break
12041   done
12042   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12043 esac
12044 
12045       $ac_path_FGREP_found && break 3
12046     done
12047   done
12048   done
12049 IFS=$as_save_IFS
12050   if test -z "$ac_cv_path_FGREP"; then
12051     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12052   fi
12053 else
12054   ac_cv_path_FGREP=$FGREP
12055 fi
12056 
12057    fi
12058 fi
12059 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12060 $as_echo "$ac_cv_path_FGREP" >&6; }
12061  FGREP="$ac_cv_path_FGREP"
12062 
12063 
12064     else
12065       # If it succeeded, then it was overridden by the user. We will use it
12066       # for the tool.
12067 
12068       # First remove it from the list of overridden variables, so we can test
12069       # for unknown variables in the end.
12070       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12071 
12072       # Check if the provided tool contains a complete path.
12073       tool_specified="$FGREP"
12074       tool_basename="${tool_specified##*/}"
12075       if test "x$tool_basename" = "x$tool_specified"; then
12076         # A command without a complete path is provided, search $PATH.
12077         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
12078 $as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
12079         # Extract the first word of "$tool_basename", so it can be a program name with args.
12080 set dummy $tool_basename; ac_word=$2
12081 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12082 $as_echo_n "checking for $ac_word... " >&6; }
12083 if ${ac_cv_path_FGREP+:} false; then :
12084   $as_echo_n "(cached) " >&6
12085 else
12086   case $FGREP in
12087   [\\/]* | ?:[\\/]*)
12088   ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
12089   ;;
12090   *)
12091   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12092 for as_dir in $PATH
12093 do
12094   IFS=$as_save_IFS
12095   test -z "$as_dir" && as_dir=.
12096     for ac_exec_ext in '' $ac_executable_extensions; do
12097   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12098     ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
12099     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12100     break 2
12101   fi
12102 done
12103   done
12104 IFS=$as_save_IFS
12105 
12106   ;;
12107 esac
12108 fi
12109 FGREP=$ac_cv_path_FGREP
12110 if test -n "$FGREP"; then
12111   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
12112 $as_echo "$FGREP" >&6; }
12113 else
12114   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12115 $as_echo "no" >&6; }
12116 fi
12117 
12118 
12119         if test "x$FGREP" = x; then
12120           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12121         fi
12122       else
12123         # Otherwise we believe it is a complete path. Use it as it is.
12124         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
12125 $as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
12126         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
12127 $as_echo_n "checking for FGREP... " >&6; }
12128         if test ! -x "$tool_specified"; then
12129           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12130 $as_echo "not found" >&6; }
12131           as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12132         fi
12133         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12134 $as_echo "$tool_specified" >&6; }
12135       fi
12136     fi
12137   fi
12138 
12139 
12140   if test "x$FGREP" = x; then
12141     as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
12142   fi
12143 
12144 
12145 
12146 
12147   # Publish this variable in the help.
12148 
12149 
12150   if test "x$SED" = x; then
12151     # The variable is not set by user, try to locate tool using the code snippet
12152     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12153 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12154 if ${ac_cv_path_SED+:} false; then :
12155   $as_echo_n "(cached) " >&6
12156 else
12157             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12158      for ac_i in 1 2 3 4 5 6 7; do
12159        ac_script="$ac_script$as_nl$ac_script"
12160      done
12161      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12162      { ac_script=; unset ac_script;}
12163      if test -z "$SED"; then
12164   ac_path_SED_found=false
12165   # Loop through the user's path and test for each of PROGNAME-LIST
12166   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12167 for as_dir in $PATH
12168 do
12169   IFS=$as_save_IFS
12170   test -z "$as_dir" && as_dir=.
12171     for ac_prog in sed gsed; do
12172     for ac_exec_ext in '' $ac_executable_extensions; do
12173       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12174       as_fn_executable_p "$ac_path_SED" || continue
12175 # Check for GNU ac_path_SED and select it if it is found.
12176   # Check for GNU $ac_path_SED
12177 case `"$ac_path_SED" --version 2>&1` in
12178 *GNU*)
12179   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12180 *)
12181   ac_count=0
12182   $as_echo_n 0123456789 >"conftest.in"
12183   while :
12184   do
12185     cat "conftest.in" "conftest.in" >"conftest.tmp"
12186     mv "conftest.tmp" "conftest.in"
12187     cp "conftest.in" "conftest.nl"
12188     $as_echo '' >> "conftest.nl"
12189     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12190     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12191     as_fn_arith $ac_count + 1 && ac_count=$as_val
12192     if test $ac_count -gt ${ac_path_SED_max-0}; then
12193       # Best one so far, save it but keep looking for a better one
12194       ac_cv_path_SED="$ac_path_SED"
12195       ac_path_SED_max=$ac_count
12196     fi
12197     # 10*(2^10) chars as input seems more than enough
12198     test $ac_count -gt 10 && break
12199   done
12200   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12201 esac
12202 
12203       $ac_path_SED_found && break 3
12204     done
12205   done
12206   done
12207 IFS=$as_save_IFS
12208   if test -z "$ac_cv_path_SED"; then
12209     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12210   fi
12211 else
12212   ac_cv_path_SED=$SED
12213 fi
12214 
12215 fi
12216 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12217 $as_echo "$ac_cv_path_SED" >&6; }
12218  SED="$ac_cv_path_SED"
12219   rm -f conftest.sed
12220 
12221   else
12222     # The variable is set, but is it from the command line or the environment?
12223 
12224     # Try to remove the string !SED! from our list.
12225     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
12226     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12227       # If it failed, the variable was not from the command line. Ignore it,
12228       # but warn the user (except for BASH, which is always set by the calling BASH).
12229       if test "xSED" != xBASH; then
12230         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
12231 $as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
12232       fi
12233       # Try to locate tool using the code snippet
12234       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12235 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12236 if ${ac_cv_path_SED+:} false; then :
12237   $as_echo_n "(cached) " >&6
12238 else
12239             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12240      for ac_i in 1 2 3 4 5 6 7; do
12241        ac_script="$ac_script$as_nl$ac_script"
12242      done
12243      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12244      { ac_script=; unset ac_script;}
12245      if test -z "$SED"; then
12246   ac_path_SED_found=false
12247   # Loop through the user's path and test for each of PROGNAME-LIST
12248   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12249 for as_dir in $PATH
12250 do
12251   IFS=$as_save_IFS
12252   test -z "$as_dir" && as_dir=.
12253     for ac_prog in sed gsed; do
12254     for ac_exec_ext in '' $ac_executable_extensions; do
12255       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12256       as_fn_executable_p "$ac_path_SED" || continue
12257 # Check for GNU ac_path_SED and select it if it is found.
12258   # Check for GNU $ac_path_SED
12259 case `"$ac_path_SED" --version 2>&1` in
12260 *GNU*)
12261   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12262 *)
12263   ac_count=0
12264   $as_echo_n 0123456789 >"conftest.in"
12265   while :
12266   do
12267     cat "conftest.in" "conftest.in" >"conftest.tmp"
12268     mv "conftest.tmp" "conftest.in"
12269     cp "conftest.in" "conftest.nl"
12270     $as_echo '' >> "conftest.nl"
12271     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12272     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12273     as_fn_arith $ac_count + 1 && ac_count=$as_val
12274     if test $ac_count -gt ${ac_path_SED_max-0}; then
12275       # Best one so far, save it but keep looking for a better one
12276       ac_cv_path_SED="$ac_path_SED"
12277       ac_path_SED_max=$ac_count
12278     fi
12279     # 10*(2^10) chars as input seems more than enough
12280     test $ac_count -gt 10 && break
12281   done
12282   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12283 esac
12284 
12285       $ac_path_SED_found && break 3
12286     done
12287   done
12288   done
12289 IFS=$as_save_IFS
12290   if test -z "$ac_cv_path_SED"; then
12291     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12292   fi
12293 else
12294   ac_cv_path_SED=$SED
12295 fi
12296 
12297 fi
12298 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12299 $as_echo "$ac_cv_path_SED" >&6; }
12300  SED="$ac_cv_path_SED"
12301   rm -f conftest.sed
12302 
12303     else
12304       # If it succeeded, then it was overridden by the user. We will use it
12305       # for the tool.
12306 
12307       # First remove it from the list of overridden variables, so we can test
12308       # for unknown variables in the end.
12309       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12310 
12311       # Check if the provided tool contains a complete path.
12312       tool_specified="$SED"
12313       tool_basename="${tool_specified##*/}"
12314       if test "x$tool_basename" = "x$tool_specified"; then
12315         # A command without a complete path is provided, search $PATH.
12316         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
12317 $as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
12318         # Extract the first word of "$tool_basename", so it can be a program name with args.
12319 set dummy $tool_basename; ac_word=$2
12320 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12321 $as_echo_n "checking for $ac_word... " >&6; }
12322 if ${ac_cv_path_SED+:} false; then :
12323   $as_echo_n "(cached) " >&6
12324 else
12325   case $SED in
12326   [\\/]* | ?:[\\/]*)
12327   ac_cv_path_SED="$SED" # Let the user override the test with a path.
12328   ;;
12329   *)
12330   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12331 for as_dir in $PATH
12332 do
12333   IFS=$as_save_IFS
12334   test -z "$as_dir" && as_dir=.
12335     for ac_exec_ext in '' $ac_executable_extensions; do
12336   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12337     ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
12338     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12339     break 2
12340   fi
12341 done
12342   done
12343 IFS=$as_save_IFS
12344 
12345   ;;
12346 esac
12347 fi
12348 SED=$ac_cv_path_SED
12349 if test -n "$SED"; then
12350   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
12351 $as_echo "$SED" >&6; }
12352 else
12353   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12354 $as_echo "no" >&6; }
12355 fi
12356 
12357 
12358         if test "x$SED" = x; then
12359           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12360         fi
12361       else
12362         # Otherwise we believe it is a complete path. Use it as it is.
12363         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
12364 $as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
12365         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
12366 $as_echo_n "checking for SED... " >&6; }
12367         if test ! -x "$tool_specified"; then
12368           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12369 $as_echo "not found" >&6; }
12370           as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
12371         fi
12372         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12373 $as_echo "$tool_specified" >&6; }
12374       fi
12375     fi
12376   fi
12377 
12378 
12379   if test "x$SED" = x; then
12380     as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
12381   fi
12382 
12383 
12384 
12385   # Always force rm.
12386   RM="$RM -f"
12387 
12388   # pwd behaves differently on various platforms and some don't support the -L flag.
12389   # Always use the bash builtin pwd to get uniform behavior.
12390   THEPWDCMD=pwd
12391 
12392   # These are not required on all platforms
12393 
12394 
12395   # Publish this variable in the help.
12396 
12397 
12398   if test "x$CYGPATH" = x; then
12399     # The variable is not set by user, try to locate tool using the code snippet
12400     for ac_prog in cygpath
12401 do
12402   # Extract the first word of "$ac_prog", so it can be a program name with args.
12403 set dummy $ac_prog; ac_word=$2
12404 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12405 $as_echo_n "checking for $ac_word... " >&6; }
12406 if ${ac_cv_path_CYGPATH+:} false; then :
12407   $as_echo_n "(cached) " >&6
12408 else
12409   case $CYGPATH in
12410   [\\/]* | ?:[\\/]*)
12411   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12412   ;;
12413   *)
12414   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12415 for as_dir in $PATH
12416 do
12417   IFS=$as_save_IFS
12418   test -z "$as_dir" && as_dir=.
12419     for ac_exec_ext in '' $ac_executable_extensions; do
12420   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12421     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12422     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12423     break 2
12424   fi
12425 done
12426   done
12427 IFS=$as_save_IFS
12428 
12429   ;;
12430 esac
12431 fi
12432 CYGPATH=$ac_cv_path_CYGPATH
12433 if test -n "$CYGPATH"; then
12434   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12435 $as_echo "$CYGPATH" >&6; }
12436 else
12437   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12438 $as_echo "no" >&6; }
12439 fi
12440 
12441 
12442   test -n "$CYGPATH" && break
12443 done
12444 
12445   else
12446     # The variable is set, but is it from the command line or the environment?
12447 
12448     # Try to remove the string !CYGPATH! from our list.
12449     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
12450     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12451       # If it failed, the variable was not from the command line. Ignore it,
12452       # but warn the user (except for BASH, which is always set by the calling BASH).
12453       if test "xCYGPATH" != xBASH; then
12454         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
12455 $as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
12456       fi
12457       # Try to locate tool using the code snippet
12458       for ac_prog in cygpath
12459 do
12460   # Extract the first word of "$ac_prog", so it can be a program name with args.
12461 set dummy $ac_prog; ac_word=$2
12462 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12463 $as_echo_n "checking for $ac_word... " >&6; }
12464 if ${ac_cv_path_CYGPATH+:} false; then :
12465   $as_echo_n "(cached) " >&6
12466 else
12467   case $CYGPATH in
12468   [\\/]* | ?:[\\/]*)
12469   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12470   ;;
12471   *)
12472   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12473 for as_dir in $PATH
12474 do
12475   IFS=$as_save_IFS
12476   test -z "$as_dir" && as_dir=.
12477     for ac_exec_ext in '' $ac_executable_extensions; do
12478   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12479     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12480     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12481     break 2
12482   fi
12483 done
12484   done
12485 IFS=$as_save_IFS
12486 
12487   ;;
12488 esac
12489 fi
12490 CYGPATH=$ac_cv_path_CYGPATH
12491 if test -n "$CYGPATH"; then
12492   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12493 $as_echo "$CYGPATH" >&6; }
12494 else
12495   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12496 $as_echo "no" >&6; }
12497 fi
12498 
12499 
12500   test -n "$CYGPATH" && break
12501 done
12502 
12503     else
12504       # If it succeeded, then it was overridden by the user. We will use it
12505       # for the tool.
12506 
12507       # First remove it from the list of overridden variables, so we can test
12508       # for unknown variables in the end.
12509       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12510 
12511       # Check if the provided tool contains a complete path.
12512       tool_specified="$CYGPATH"
12513       tool_basename="${tool_specified##*/}"
12514       if test "x$tool_basename" = "x$tool_specified"; then
12515         # A command without a complete path is provided, search $PATH.
12516         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
12517 $as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
12518         # Extract the first word of "$tool_basename", so it can be a program name with args.
12519 set dummy $tool_basename; ac_word=$2
12520 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12521 $as_echo_n "checking for $ac_word... " >&6; }
12522 if ${ac_cv_path_CYGPATH+:} false; then :
12523   $as_echo_n "(cached) " >&6
12524 else
12525   case $CYGPATH in
12526   [\\/]* | ?:[\\/]*)
12527   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12528   ;;
12529   *)
12530   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12531 for as_dir in $PATH
12532 do
12533   IFS=$as_save_IFS
12534   test -z "$as_dir" && as_dir=.
12535     for ac_exec_ext in '' $ac_executable_extensions; do
12536   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12537     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12538     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12539     break 2
12540   fi
12541 done
12542   done
12543 IFS=$as_save_IFS
12544 
12545   ;;
12546 esac
12547 fi
12548 CYGPATH=$ac_cv_path_CYGPATH
12549 if test -n "$CYGPATH"; then
12550   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12551 $as_echo "$CYGPATH" >&6; }
12552 else
12553   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12554 $as_echo "no" >&6; }
12555 fi
12556 
12557 
12558         if test "x$CYGPATH" = x; then
12559           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12560         fi
12561       else
12562         # Otherwise we believe it is a complete path. Use it as it is.
12563         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
12564 $as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
12565         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
12566 $as_echo_n "checking for CYGPATH... " >&6; }
12567         if test ! -x "$tool_specified"; then
12568           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12569 $as_echo "not found" >&6; }
12570           as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
12571         fi
12572         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12573 $as_echo "$tool_specified" >&6; }
12574       fi
12575     fi
12576   fi
12577 
12578 
12579 
12580 
12581   # Publish this variable in the help.
12582 
12583 
12584   if test "x$READLINK" = x; then
12585     # The variable is not set by user, try to locate tool using the code snippet
12586     for ac_prog in greadlink readlink
12587 do
12588   # Extract the first word of "$ac_prog", so it can be a program name with args.
12589 set dummy $ac_prog; ac_word=$2
12590 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12591 $as_echo_n "checking for $ac_word... " >&6; }
12592 if ${ac_cv_path_READLINK+:} false; then :
12593   $as_echo_n "(cached) " >&6
12594 else
12595   case $READLINK in
12596   [\\/]* | ?:[\\/]*)
12597   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12598   ;;
12599   *)
12600   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12601 for as_dir in $PATH
12602 do
12603   IFS=$as_save_IFS
12604   test -z "$as_dir" && as_dir=.
12605     for ac_exec_ext in '' $ac_executable_extensions; do
12606   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12607     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12608     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12609     break 2
12610   fi
12611 done
12612   done
12613 IFS=$as_save_IFS
12614 
12615   ;;
12616 esac
12617 fi
12618 READLINK=$ac_cv_path_READLINK
12619 if test -n "$READLINK"; then
12620   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12621 $as_echo "$READLINK" >&6; }
12622 else
12623   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12624 $as_echo "no" >&6; }
12625 fi
12626 
12627 
12628   test -n "$READLINK" && break
12629 done
12630 
12631   else
12632     # The variable is set, but is it from the command line or the environment?
12633 
12634     # Try to remove the string !READLINK! from our list.
12635     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
12636     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12637       # If it failed, the variable was not from the command line. Ignore it,
12638       # but warn the user (except for BASH, which is always set by the calling BASH).
12639       if test "xREADLINK" != xBASH; then
12640         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
12641 $as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
12642       fi
12643       # Try to locate tool using the code snippet
12644       for ac_prog in greadlink readlink
12645 do
12646   # Extract the first word of "$ac_prog", so it can be a program name with args.
12647 set dummy $ac_prog; ac_word=$2
12648 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12649 $as_echo_n "checking for $ac_word... " >&6; }
12650 if ${ac_cv_path_READLINK+:} false; then :
12651   $as_echo_n "(cached) " >&6
12652 else
12653   case $READLINK in
12654   [\\/]* | ?:[\\/]*)
12655   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12656   ;;
12657   *)
12658   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12659 for as_dir in $PATH
12660 do
12661   IFS=$as_save_IFS
12662   test -z "$as_dir" && as_dir=.
12663     for ac_exec_ext in '' $ac_executable_extensions; do
12664   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12665     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12666     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12667     break 2
12668   fi
12669 done
12670   done
12671 IFS=$as_save_IFS
12672 
12673   ;;
12674 esac
12675 fi
12676 READLINK=$ac_cv_path_READLINK
12677 if test -n "$READLINK"; then
12678   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12679 $as_echo "$READLINK" >&6; }
12680 else
12681   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12682 $as_echo "no" >&6; }
12683 fi
12684 
12685 
12686   test -n "$READLINK" && break
12687 done
12688 
12689     else
12690       # If it succeeded, then it was overridden by the user. We will use it
12691       # for the tool.
12692 
12693       # First remove it from the list of overridden variables, so we can test
12694       # for unknown variables in the end.
12695       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12696 
12697       # Check if the provided tool contains a complete path.
12698       tool_specified="$READLINK"
12699       tool_basename="${tool_specified##*/}"
12700       if test "x$tool_basename" = "x$tool_specified"; then
12701         # A command without a complete path is provided, search $PATH.
12702         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
12703 $as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
12704         # Extract the first word of "$tool_basename", so it can be a program name with args.
12705 set dummy $tool_basename; ac_word=$2
12706 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12707 $as_echo_n "checking for $ac_word... " >&6; }
12708 if ${ac_cv_path_READLINK+:} false; then :
12709   $as_echo_n "(cached) " >&6
12710 else
12711   case $READLINK in
12712   [\\/]* | ?:[\\/]*)
12713   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12714   ;;
12715   *)
12716   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12717 for as_dir in $PATH
12718 do
12719   IFS=$as_save_IFS
12720   test -z "$as_dir" && as_dir=.
12721     for ac_exec_ext in '' $ac_executable_extensions; do
12722   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12723     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12724     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12725     break 2
12726   fi
12727 done
12728   done
12729 IFS=$as_save_IFS
12730 
12731   ;;
12732 esac
12733 fi
12734 READLINK=$ac_cv_path_READLINK
12735 if test -n "$READLINK"; then
12736   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12737 $as_echo "$READLINK" >&6; }
12738 else
12739   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12740 $as_echo "no" >&6; }
12741 fi
12742 
12743 
12744         if test "x$READLINK" = x; then
12745           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12746         fi
12747       else
12748         # Otherwise we believe it is a complete path. Use it as it is.
12749         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
12750 $as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
12751         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
12752 $as_echo_n "checking for READLINK... " >&6; }
12753         if test ! -x "$tool_specified"; then
12754           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12755 $as_echo "not found" >&6; }
12756           as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
12757         fi
12758         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12759 $as_echo "$tool_specified" >&6; }
12760       fi
12761     fi
12762   fi
12763 
12764 
12765 
12766 
12767   # Publish this variable in the help.
12768 
12769 
12770   if test "x$DF" = x; then
12771     # The variable is not set by user, try to locate tool using the code snippet
12772     for ac_prog in df
12773 do
12774   # Extract the first word of "$ac_prog", so it can be a program name with args.
12775 set dummy $ac_prog; ac_word=$2
12776 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12777 $as_echo_n "checking for $ac_word... " >&6; }
12778 if ${ac_cv_path_DF+:} false; then :
12779   $as_echo_n "(cached) " >&6
12780 else
12781   case $DF in
12782   [\\/]* | ?:[\\/]*)
12783   ac_cv_path_DF="$DF" # Let the user override the test with a path.
12784   ;;
12785   *)
12786   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12787 for as_dir in $PATH
12788 do
12789   IFS=$as_save_IFS
12790   test -z "$as_dir" && as_dir=.
12791     for ac_exec_ext in '' $ac_executable_extensions; do
12792   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12793     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12794     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12795     break 2
12796   fi
12797 done
12798   done
12799 IFS=$as_save_IFS
12800 
12801   ;;
12802 esac
12803 fi
12804 DF=$ac_cv_path_DF
12805 if test -n "$DF"; then
12806   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12807 $as_echo "$DF" >&6; }
12808 else
12809   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12810 $as_echo "no" >&6; }
12811 fi
12812 
12813 
12814   test -n "$DF" && break
12815 done
12816 
12817   else
12818     # The variable is set, but is it from the command line or the environment?
12819 
12820     # Try to remove the string !DF! from our list.
12821     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
12822     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12823       # If it failed, the variable was not from the command line. Ignore it,
12824       # but warn the user (except for BASH, which is always set by the calling BASH).
12825       if test "xDF" != xBASH; then
12826         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
12827 $as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
12828       fi
12829       # Try to locate tool using the code snippet
12830       for ac_prog in df
12831 do
12832   # Extract the first word of "$ac_prog", so it can be a program name with args.
12833 set dummy $ac_prog; ac_word=$2
12834 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12835 $as_echo_n "checking for $ac_word... " >&6; }
12836 if ${ac_cv_path_DF+:} false; then :
12837   $as_echo_n "(cached) " >&6
12838 else
12839   case $DF in
12840   [\\/]* | ?:[\\/]*)
12841   ac_cv_path_DF="$DF" # Let the user override the test with a path.
12842   ;;
12843   *)
12844   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12845 for as_dir in $PATH
12846 do
12847   IFS=$as_save_IFS
12848   test -z "$as_dir" && as_dir=.
12849     for ac_exec_ext in '' $ac_executable_extensions; do
12850   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12851     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12852     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12853     break 2
12854   fi
12855 done
12856   done
12857 IFS=$as_save_IFS
12858 
12859   ;;
12860 esac
12861 fi
12862 DF=$ac_cv_path_DF
12863 if test -n "$DF"; then
12864   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12865 $as_echo "$DF" >&6; }
12866 else
12867   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12868 $as_echo "no" >&6; }
12869 fi
12870 
12871 
12872   test -n "$DF" && break
12873 done
12874 
12875     else
12876       # If it succeeded, then it was overridden by the user. We will use it
12877       # for the tool.
12878 
12879       # First remove it from the list of overridden variables, so we can test
12880       # for unknown variables in the end.
12881       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12882 
12883       # Check if the provided tool contains a complete path.
12884       tool_specified="$DF"
12885       tool_basename="${tool_specified##*/}"
12886       if test "x$tool_basename" = "x$tool_specified"; then
12887         # A command without a complete path is provided, search $PATH.
12888         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
12889 $as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
12890         # Extract the first word of "$tool_basename", so it can be a program name with args.
12891 set dummy $tool_basename; ac_word=$2
12892 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12893 $as_echo_n "checking for $ac_word... " >&6; }
12894 if ${ac_cv_path_DF+:} false; then :
12895   $as_echo_n "(cached) " >&6
12896 else
12897   case $DF in
12898   [\\/]* | ?:[\\/]*)
12899   ac_cv_path_DF="$DF" # Let the user override the test with a path.
12900   ;;
12901   *)
12902   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12903 for as_dir in $PATH
12904 do
12905   IFS=$as_save_IFS
12906   test -z "$as_dir" && as_dir=.
12907     for ac_exec_ext in '' $ac_executable_extensions; do
12908   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12909     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12910     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12911     break 2
12912   fi
12913 done
12914   done
12915 IFS=$as_save_IFS
12916 
12917   ;;
12918 esac
12919 fi
12920 DF=$ac_cv_path_DF
12921 if test -n "$DF"; then
12922   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12923 $as_echo "$DF" >&6; }
12924 else
12925   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12926 $as_echo "no" >&6; }
12927 fi
12928 
12929 
12930         if test "x$DF" = x; then
12931           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12932         fi
12933       else
12934         # Otherwise we believe it is a complete path. Use it as it is.
12935         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
12936 $as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
12937         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
12938 $as_echo_n "checking for DF... " >&6; }
12939         if test ! -x "$tool_specified"; then
12940           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12941 $as_echo "not found" >&6; }
12942           as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
12943         fi
12944         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12945 $as_echo "$tool_specified" >&6; }
12946       fi
12947     fi
12948   fi
12949 
12950 
12951 
12952 
12953   # Publish this variable in the help.
12954 
12955 
12956   if test "x$SETFILE" = x; then
12957     # The variable is not set by user, try to locate tool using the code snippet
12958     for ac_prog in SetFile
12959 do
12960   # Extract the first word of "$ac_prog", so it can be a program name with args.
12961 set dummy $ac_prog; ac_word=$2
12962 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12963 $as_echo_n "checking for $ac_word... " >&6; }
12964 if ${ac_cv_path_SETFILE+:} false; then :
12965   $as_echo_n "(cached) " >&6
12966 else
12967   case $SETFILE in
12968   [\\/]* | ?:[\\/]*)
12969   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
12970   ;;
12971   *)
12972   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12973 for as_dir in $PATH
12974 do
12975   IFS=$as_save_IFS
12976   test -z "$as_dir" && as_dir=.
12977     for ac_exec_ext in '' $ac_executable_extensions; do
12978   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12979     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
12980     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12981     break 2
12982   fi
12983 done
12984   done
12985 IFS=$as_save_IFS
12986 
12987   ;;
12988 esac
12989 fi
12990 SETFILE=$ac_cv_path_SETFILE
12991 if test -n "$SETFILE"; then
12992   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
12993 $as_echo "$SETFILE" >&6; }
12994 else
12995   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12996 $as_echo "no" >&6; }
12997 fi
12998 
12999 
13000   test -n "$SETFILE" && break
13001 done
13002 
13003   else
13004     # The variable is set, but is it from the command line or the environment?
13005 
13006     # Try to remove the string !SETFILE! from our list.
13007     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
13008     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13009       # If it failed, the variable was not from the command line. Ignore it,
13010       # but warn the user (except for BASH, which is always set by the calling BASH).
13011       if test "xSETFILE" != xBASH; then
13012         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
13013 $as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
13014       fi
13015       # Try to locate tool using the code snippet
13016       for ac_prog in SetFile
13017 do
13018   # Extract the first word of "$ac_prog", so it can be a program name with args.
13019 set dummy $ac_prog; ac_word=$2
13020 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13021 $as_echo_n "checking for $ac_word... " >&6; }
13022 if ${ac_cv_path_SETFILE+:} false; then :
13023   $as_echo_n "(cached) " >&6
13024 else
13025   case $SETFILE in
13026   [\\/]* | ?:[\\/]*)
13027   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13028   ;;
13029   *)
13030   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13031 for as_dir in $PATH
13032 do
13033   IFS=$as_save_IFS
13034   test -z "$as_dir" && as_dir=.
13035     for ac_exec_ext in '' $ac_executable_extensions; do
13036   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13037     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13038     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13039     break 2
13040   fi
13041 done
13042   done
13043 IFS=$as_save_IFS
13044 
13045   ;;
13046 esac
13047 fi
13048 SETFILE=$ac_cv_path_SETFILE
13049 if test -n "$SETFILE"; then
13050   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13051 $as_echo "$SETFILE" >&6; }
13052 else
13053   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13054 $as_echo "no" >&6; }
13055 fi
13056 
13057 
13058   test -n "$SETFILE" && break
13059 done
13060 
13061     else
13062       # If it succeeded, then it was overridden by the user. We will use it
13063       # for the tool.
13064 
13065       # First remove it from the list of overridden variables, so we can test
13066       # for unknown variables in the end.
13067       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13068 
13069       # Check if the provided tool contains a complete path.
13070       tool_specified="$SETFILE"
13071       tool_basename="${tool_specified##*/}"
13072       if test "x$tool_basename" = "x$tool_specified"; then
13073         # A command without a complete path is provided, search $PATH.
13074         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
13075 $as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
13076         # Extract the first word of "$tool_basename", so it can be a program name with args.
13077 set dummy $tool_basename; ac_word=$2
13078 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13079 $as_echo_n "checking for $ac_word... " >&6; }
13080 if ${ac_cv_path_SETFILE+:} false; then :
13081   $as_echo_n "(cached) " >&6
13082 else
13083   case $SETFILE in
13084   [\\/]* | ?:[\\/]*)
13085   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13086   ;;
13087   *)
13088   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13089 for as_dir in $PATH
13090 do
13091   IFS=$as_save_IFS
13092   test -z "$as_dir" && as_dir=.
13093     for ac_exec_ext in '' $ac_executable_extensions; do
13094   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13095     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13096     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13097     break 2
13098   fi
13099 done
13100   done
13101 IFS=$as_save_IFS
13102 
13103   ;;
13104 esac
13105 fi
13106 SETFILE=$ac_cv_path_SETFILE
13107 if test -n "$SETFILE"; then
13108   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13109 $as_echo "$SETFILE" >&6; }
13110 else
13111   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13112 $as_echo "no" >&6; }
13113 fi
13114 
13115 
13116         if test "x$SETFILE" = x; then
13117           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13118         fi
13119       else
13120         # Otherwise we believe it is a complete path. Use it as it is.
13121         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
13122 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
13123         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
13124 $as_echo_n "checking for SETFILE... " >&6; }
13125         if test ! -x "$tool_specified"; then
13126           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13127 $as_echo "not found" >&6; }
13128           as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
13129         fi
13130         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13131 $as_echo "$tool_specified" >&6; }
13132       fi
13133     fi
13134   fi
13135 
13136 
13137 
13138 
13139 # Now we can determine OpenJDK build and target platforms. This is required to
13140 # have early on.
13141 # Make sure we can run config.sub.
13142 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
13143   as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
13144 
13145 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
13146 $as_echo_n "checking build system type... " >&6; }
13147 if ${ac_cv_build+:} false; then :
13148   $as_echo_n "(cached) " >&6
13149 else
13150   ac_build_alias=$build_alias
13151 test "x$ac_build_alias" = x &&
13152   ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
13153 test "x$ac_build_alias" = x &&
13154   as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
13155 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
13156   as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
13157 
13158 fi
13159 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
13160 $as_echo "$ac_cv_build" >&6; }
13161 case $ac_cv_build in
13162 *-*-*) ;;
13163 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
13164 esac
13165 build=$ac_cv_build
13166 ac_save_IFS=$IFS; IFS='-'
13167 set x $ac_cv_build
13168 shift
13169 build_cpu=$1
13170 build_vendor=$2
13171 shift; shift
13172 # Remember, the first character of IFS is used to create $*,
13173 # except with old shells:
13174 build_os=$*
13175 IFS=$ac_save_IFS
13176 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
13177 
13178 
13179 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
13180 $as_echo_n "checking host system type... " >&6; }
13181 if ${ac_cv_host+:} false; then :
13182   $as_echo_n "(cached) " >&6
13183 else
13184   if test "x$host_alias" = x; then
13185   ac_cv_host=$ac_cv_build
13186 else
13187   ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
13188     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
13189 fi
13190 
13191 fi
13192 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
13193 $as_echo "$ac_cv_host" >&6; }
13194 case $ac_cv_host in
13195 *-*-*) ;;
13196 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
13197 esac
13198 host=$ac_cv_host
13199 ac_save_IFS=$IFS; IFS='-'
13200 set x $ac_cv_host
13201 shift
13202 host_cpu=$1
13203 host_vendor=$2
13204 shift; shift
13205 # Remember, the first character of IFS is used to create $*,
13206 # except with old shells:
13207 host_os=$*
13208 IFS=$ac_save_IFS
13209 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
13210 
13211 
13212 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
13213 $as_echo_n "checking target system type... " >&6; }
13214 if ${ac_cv_target+:} false; then :
13215   $as_echo_n "(cached) " >&6
13216 else
13217   if test "x$target_alias" = x; then
13218   ac_cv_target=$ac_cv_host
13219 else
13220   ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
13221     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
13222 fi
13223 
13224 fi
13225 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
13226 $as_echo "$ac_cv_target" >&6; }
13227 case $ac_cv_target in
13228 *-*-*) ;;
13229 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
13230 esac
13231 target=$ac_cv_target
13232 ac_save_IFS=$IFS; IFS='-'
13233 set x $ac_cv_target
13234 shift
13235 target_cpu=$1
13236 target_vendor=$2
13237 shift; shift
13238 # Remember, the first character of IFS is used to create $*,
13239 # except with old shells:
13240 target_os=$*
13241 IFS=$ac_save_IFS
13242 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
13243 
13244 
13245 # The aliases save the names the user supplied, while $host etc.
13246 # will get canonicalized.
13247 test -n "$target_alias" &&
13248   test "$program_prefix$program_suffix$program_transform_name" = \
13249     NONENONEs,x,x, &&
13250   program_prefix=${target_alias}-
13251 
13252   # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
13253   # is confusing; it assumes you are cross-compiling a cross-compiler (!)  and "target" is thus the target of the
13254   # product you're building. The target of this build is called "host". Since this is confusing to most people, we
13255   # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
13256   # to use the configure naming style.
13257 
13258 
13259 
13260 
13261 
13262   # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
13263   # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
13264   # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
13265   # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
13266   OPENJDK_TARGET_AUTOCONF_NAME="$host"
13267   OPENJDK_BUILD_AUTOCONF_NAME="$build"
13268 
13269 
13270 
13271   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13272 
13273   case "$build_os" in
13274     *linux*)
13275       VAR_OS=linux
13276       VAR_OS_API=posix
13277       VAR_OS_ENV=linux
13278       ;;
13279     *solaris*)
13280       VAR_OS=solaris
13281       VAR_OS_API=posix
13282       VAR_OS_ENV=solaris
13283       ;;
13284     *darwin*)
13285       VAR_OS=macosx
13286       VAR_OS_API=posix
13287       VAR_OS_ENV=macosx
13288       ;;
13289     *bsd*)
13290       VAR_OS=bsd
13291       VAR_OS_API=posix
13292       VAR_OS_ENV=bsd
13293       ;;
13294     *cygwin*)
13295       VAR_OS=windows
13296       VAR_OS_API=winapi
13297       VAR_OS_ENV=windows.cygwin
13298       ;;
13299     *mingw*)
13300       VAR_OS=windows
13301       VAR_OS_API=winapi
13302       VAR_OS_ENV=windows.msys
13303       ;;
13304     *aix*)
13305       VAR_OS=aix
13306       VAR_OS_API=posix
13307       VAR_OS_ENV=aix
13308       ;;
13309     *)
13310       as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
13311       ;;
13312   esac
13313 
13314 
13315   # First argument is the cpu name from the trip/quad
13316   case "$build_cpu" in
13317     x86_64)
13318       VAR_CPU=x86_64
13319       VAR_CPU_ARCH=x86
13320       VAR_CPU_BITS=64
13321       VAR_CPU_ENDIAN=little
13322       ;;
13323     i?86)
13324       VAR_CPU=x86
13325       VAR_CPU_ARCH=x86
13326       VAR_CPU_BITS=32
13327       VAR_CPU_ENDIAN=little
13328       ;;
13329     arm*)
13330       VAR_CPU=arm
13331       VAR_CPU_ARCH=arm
13332       VAR_CPU_BITS=32
13333       VAR_CPU_ENDIAN=little
13334       ;;
13335     powerpc)
13336       VAR_CPU=ppc
13337       VAR_CPU_ARCH=ppc
13338       VAR_CPU_BITS=32
13339       VAR_CPU_ENDIAN=big
13340       ;;
13341     powerpc64)
13342       VAR_CPU=ppc64
13343       VAR_CPU_ARCH=ppc
13344       VAR_CPU_BITS=64
13345       VAR_CPU_ENDIAN=big
13346       ;;
13347     s390)
13348       VAR_CPU=s390
13349       VAR_CPU_ARCH=s390
13350       VAR_CPU_BITS=32
13351       VAR_CPU_ENDIAN=big
13352       ;;
13353     s390x)
13354       VAR_CPU=s390x
13355       VAR_CPU_ARCH=s390
13356       VAR_CPU_BITS=64
13357       VAR_CPU_ENDIAN=big
13358       ;;
13359     sparc)
13360       VAR_CPU=sparc
13361       VAR_CPU_ARCH=sparc
13362       VAR_CPU_BITS=32
13363       VAR_CPU_ENDIAN=big
13364       ;;
13365     sparcv9)
13366       VAR_CPU=sparcv9
13367       VAR_CPU_ARCH=sparc
13368       VAR_CPU_BITS=64
13369       VAR_CPU_ENDIAN=big
13370       ;;
13371     *)
13372       as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
13373       ;;
13374   esac
13375 
13376   # ..and setup our own variables. (Do this explicitely to facilitate searching)
13377   OPENJDK_BUILD_OS="$VAR_OS"
13378   OPENJDK_BUILD_OS_API="$VAR_OS_API"
13379   OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
13380   OPENJDK_BUILD_CPU="$VAR_CPU"
13381   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
13382   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
13383   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13384 
13385 
13386 
13387 
13388 
13389 
13390 
13391   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
13392 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
13393   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
13394 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
13395 
13396   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13397 
13398   case "$host_os" in
13399     *linux*)
13400       VAR_OS=linux
13401       VAR_OS_API=posix
13402       VAR_OS_ENV=linux
13403       ;;
13404     *solaris*)
13405       VAR_OS=solaris
13406       VAR_OS_API=posix
13407       VAR_OS_ENV=solaris
13408       ;;
13409     *darwin*)
13410       VAR_OS=macosx
13411       VAR_OS_API=posix
13412       VAR_OS_ENV=macosx
13413       ;;
13414     *bsd*)
13415       VAR_OS=bsd
13416       VAR_OS_API=posix
13417       VAR_OS_ENV=bsd
13418       ;;
13419     *cygwin*)
13420       VAR_OS=windows
13421       VAR_OS_API=winapi
13422       VAR_OS_ENV=windows.cygwin
13423       ;;
13424     *mingw*)
13425       VAR_OS=windows
13426       VAR_OS_API=winapi
13427       VAR_OS_ENV=windows.msys
13428       ;;
13429     *aix*)
13430       VAR_OS=aix
13431       VAR_OS_API=posix
13432       VAR_OS_ENV=aix
13433       ;;
13434     *)
13435       as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
13436       ;;
13437   esac
13438 
13439 
13440   # First argument is the cpu name from the trip/quad
13441   case "$host_cpu" in
13442     x86_64)
13443       VAR_CPU=x86_64
13444       VAR_CPU_ARCH=x86
13445       VAR_CPU_BITS=64
13446       VAR_CPU_ENDIAN=little
13447       ;;
13448     i?86)
13449       VAR_CPU=x86
13450       VAR_CPU_ARCH=x86
13451       VAR_CPU_BITS=32
13452       VAR_CPU_ENDIAN=little
13453       ;;
13454     arm*)
13455       VAR_CPU=arm
13456       VAR_CPU_ARCH=arm
13457       VAR_CPU_BITS=32
13458       VAR_CPU_ENDIAN=little
13459       ;;
13460     powerpc)
13461       VAR_CPU=ppc
13462       VAR_CPU_ARCH=ppc
13463       VAR_CPU_BITS=32
13464       VAR_CPU_ENDIAN=big
13465       ;;
13466     powerpc64)
13467       VAR_CPU=ppc64
13468       VAR_CPU_ARCH=ppc
13469       VAR_CPU_BITS=64
13470       VAR_CPU_ENDIAN=big
13471       ;;
13472     s390)
13473       VAR_CPU=s390
13474       VAR_CPU_ARCH=s390
13475       VAR_CPU_BITS=32
13476       VAR_CPU_ENDIAN=big
13477       ;;
13478     s390x)
13479       VAR_CPU=s390x
13480       VAR_CPU_ARCH=s390
13481       VAR_CPU_BITS=64
13482       VAR_CPU_ENDIAN=big
13483       ;;
13484     sparc)
13485       VAR_CPU=sparc
13486       VAR_CPU_ARCH=sparc
13487       VAR_CPU_BITS=32
13488       VAR_CPU_ENDIAN=big
13489       ;;
13490     sparcv9)
13491       VAR_CPU=sparcv9
13492       VAR_CPU_ARCH=sparc
13493       VAR_CPU_BITS=64
13494       VAR_CPU_ENDIAN=big
13495       ;;
13496     *)
13497       as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
13498       ;;
13499   esac
13500 
13501   # ... and setup our own variables. (Do this explicitely to facilitate searching)
13502   OPENJDK_TARGET_OS="$VAR_OS"
13503   OPENJDK_TARGET_OS_API="$VAR_OS_API"
13504   OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
13505   OPENJDK_TARGET_CPU="$VAR_CPU"
13506   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
13507   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
13508   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13509 
13510 
13511 
13512 
13513 
13514 
13515 
13516   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
13517 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
13518   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
13519 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
13520 
13521 
13522 
13523 # Check whether --with-target-bits was given.
13524 if test "${with_target_bits+set}" = set; then :
13525   withval=$with_target_bits;
13526 fi
13527 
13528 
13529   # We have three types of compiles:
13530   # native  == normal compilation, target system == build system
13531   # cross   == traditional cross compilation, target system != build system; special toolchain needed
13532   # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
13533   #
13534   if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
13535     # We're doing a proper cross-compilation
13536     COMPILE_TYPE="cross"
13537   else
13538     COMPILE_TYPE="native"
13539   fi
13540 
13541   if test "x$with_target_bits" != x; then
13542     if test "x$COMPILE_TYPE" = "xcross"; then
13543       as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
13544     fi
13545 
13546     if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13547       # A reduced build is requested
13548       COMPILE_TYPE="reduced"
13549       OPENJDK_TARGET_CPU_BITS=32
13550       if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
13551         OPENJDK_TARGET_CPU=x86
13552       elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
13553         OPENJDK_TARGET_CPU=sparc
13554       else
13555         as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
13556       fi
13557     elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
13558       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
13559     elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
13560       { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
13561 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
13562     else
13563       as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
13564     fi
13565   fi
13566 
13567 
13568   { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
13569 $as_echo_n "checking compilation type... " >&6; }
13570   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
13571 $as_echo "$COMPILE_TYPE" >&6; }
13572 
13573 
13574   if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
13575     REQUIRED_OS_NAME=SunOS
13576     REQUIRED_OS_VERSION=5.10
13577   fi
13578   if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
13579     REQUIRED_OS_NAME=Linux
13580     REQUIRED_OS_VERSION=2.6
13581   fi
13582   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
13583     REQUIRED_OS_NAME=Windows
13584     if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
13585       REQUIRED_OS_VERSION=5.2
13586     else
13587       REQUIRED_OS_VERSION=5.1
13588     fi
13589   fi
13590   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
13591     REQUIRED_OS_NAME=Darwin
13592     REQUIRED_OS_VERSION=11.2
13593   fi
13594 
13595 
13596 
13597 
13598 
13599   # Also store the legacy naming of the cpu.
13600   # Ie i586 and amd64 instead of x86 and x86_64
13601   OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
13602   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13603     OPENJDK_TARGET_CPU_LEGACY="i586"
13604   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13605     # On all platforms except MacOSX replace x86_64 with amd64.
13606     OPENJDK_TARGET_CPU_LEGACY="amd64"
13607   fi
13608 
13609 
13610   # And the second legacy naming of the cpu.
13611   # Ie i386 and amd64 instead of x86 and x86_64.
13612   OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
13613   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13614     OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
13615   elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13616     OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
13617   fi
13618 
13619 
13620   # This is the name of the cpu (but using i386 and amd64 instead of
13621   # x86 and x86_64, respectively), preceeded by a /, to be used when
13622   # locating libraries. On macosx, it's empty, though.
13623   OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
13624   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13625     OPENJDK_TARGET_CPU_LIBDIR=""
13626   fi
13627 
13628 
13629   # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
13630   # /amd64 or /sparcv9. This string is appended to some library paths, like this:
13631   # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
13632   OPENJDK_TARGET_CPU_ISADIR=""
13633   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13634     if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13635       OPENJDK_TARGET_CPU_ISADIR="/amd64"
13636     elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
13637       OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
13638     fi
13639   fi
13640 
13641 
13642   # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
13643   OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
13644   if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
13645     # On linux only, we replace x86 with i386.
13646     OPENJDK_TARGET_CPU_OSARCH="i386"
13647   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13648     # On all platforms except macosx, we replace x86_64 with amd64.
13649     OPENJDK_TARGET_CPU_OSARCH="amd64"
13650   fi
13651 
13652 
13653   OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
13654   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13655     OPENJDK_TARGET_CPU_JLI="i386"
13656   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13657     # On all platforms except macosx, we replace x86_64 with amd64.
13658     OPENJDK_TARGET_CPU_JLI="amd64"
13659   fi
13660   # Now setup the -D flags for building libjli.
13661   OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
13662   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13663     if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
13664       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
13665     elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
13666       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
13667     fi
13668   fi
13669 
13670 
13671   # Setup OPENJDK_TARGET_OS_API_DIR, used in source paths.
13672   if test "x$OPENJDK_TARGET_OS_API" = xposix; then
13673     OPENJDK_TARGET_OS_API_DIR="solaris"
13674   fi
13675   if test "x$OPENJDK_TARGET_OS_API" = xwinapi; then
13676     OPENJDK_TARGET_OS_API_DIR="windows"
13677   fi
13678 
13679 
13680   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13681       OPENJDK_TARGET_OS_EXPORT_DIR=macosx
13682   else
13683       OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_API_DIR}
13684   fi
13685 
13686 
13687   if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13688     A_LP64="LP64:="
13689     # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
13690     # unpack200.exe
13691     if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
13692       ADD_LP64="-D_LP64=1"
13693     fi
13694   fi
13695   LP64=$A_LP64
13696 
13697 
13698   if test "x$COMPILE_TYPE" = "xcross"; then
13699     # FIXME: ... or should this include reduced builds..?
13700     DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
13701   else
13702     DEFINE_CROSS_COMPILE_ARCH=""
13703   fi
13704 
13705 
13706   # ZERO_ARCHDEF is used to enable architecture-specific code
13707   case "${OPENJDK_TARGET_CPU}" in
13708     ppc*)    ZERO_ARCHDEF=PPC   ;;
13709     s390*)   ZERO_ARCHDEF=S390  ;;
13710     sparc*)  ZERO_ARCHDEF=SPARC ;;
13711     x86_64*) ZERO_ARCHDEF=AMD64 ;;
13712     x86)     ZERO_ARCHDEF=IA32  ;;
13713     *)      ZERO_ARCHDEF=$(echo "${OPENJDK_TARGET_CPU_LEGACY_LIB}" | tr a-z A-Z)
13714   esac
13715 
13716 
13717 
13718 
13719 # Continue setting up basic stuff. Most remaining code require fundamental tools.
13720 
13721   # Locate the directory of this script.
13722   SCRIPT="$0"
13723   AUTOCONF_DIR=`cd \`$DIRNAME $SCRIPT\`; $THEPWDCMD -L`
13724 
13725   # Where is the source? It is located two levels above the configure script.
13726   CURDIR="$PWD"
13727   cd "$AUTOCONF_DIR/../.."
13728   SRC_ROOT="`$THEPWDCMD -L`"
13729 
13730   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
13731     PATH_SEP=";"
13732 
13733   SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
13734   if test $SRC_ROOT_LENGTH -gt 100; then
13735     as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
13736   fi
13737 
13738   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13739     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
13740 $as_echo_n "checking cygwin release... " >&6; }
13741     CYGWIN_VERSION=`$UNAME -r`
13742     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
13743 $as_echo "$CYGWIN_VERSION" >&6; }
13744     WINDOWS_ENV_VENDOR='cygwin'
13745     WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
13746 
13747     CYGWIN_VERSION_OK=`$ECHO $CYGWIN_VERSION | $GREP ^1.7.`
13748     if test "x$CYGWIN_VERSION_OK" = x; then
13749       { $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
13750 $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;}
13751       as_fn_error $? "Cannot continue" "$LINENO" 5
13752     fi
13753     if test "x$CYGPATH" = x; then
13754       as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
13755     fi
13756     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
13757 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
13758     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
13759     cygwin_winpath_root=`cd / ; cmd /c cd | grep ".*"`
13760     # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
13761     CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
13762     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
13763 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
13764     WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
13765     test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
13766     if test "x$test_cygdrive_prefix" = x; then
13767       as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
13768     fi
13769   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
13770     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
13771 $as_echo_n "checking msys release... " >&6; }
13772     MSYS_VERSION=`$UNAME -r`
13773     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
13774 $as_echo "$MSYS_VERSION" >&6; }
13775 
13776     WINDOWS_ENV_VENDOR='msys'
13777     WINDOWS_ENV_VERSION="$MSYS_VERSION"
13778 
13779     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
13780 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
13781     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
13782     MSYS_ROOT_PATH=`cd / ; cmd /c cd | grep ".*"`
13783 
13784   windows_path="$MSYS_ROOT_PATH"
13785   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13786     unix_path=`$CYGPATH -u "$windows_path"`
13787     MSYS_ROOT_PATH="$unix_path"
13788   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
13789     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
13790     MSYS_ROOT_PATH="$unix_path"
13791   fi
13792 
13793     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
13794 $as_echo "$MSYS_ROOT_PATH" >&6; }
13795     WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
13796   else
13797     as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
13798   fi
13799 
13800   # Test if windows or unix (cygwin/msys) find is first in path.
13801   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
13802 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
13803   FIND_BINARY_OUTPUT=`find --version 2>&1`
13804   if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
13805     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
13806 $as_echo "unix style" >&6; }
13807   elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
13808     { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
13809 $as_echo "Windows" >&6; }
13810     { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
13811 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
13812     { $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
13813 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
13814     as_fn_error $? "Cannot continue" "$LINENO" 5
13815   else
13816     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
13817 $as_echo "unknown" >&6; }
13818     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
13819 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
13820   fi
13821 
13822   else
13823     PATH_SEP=":"
13824   fi
13825 
13826 
13827 
13828   cd "$CURDIR"
13829 
13830 
13831   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13832 
13833   # Input might be given as Windows format, start by converting to
13834   # unix format.
13835   path="$SRC_ROOT"
13836   new_path=`$CYGPATH -u "$path"`
13837 
13838   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
13839   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
13840   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
13841   # "foo.exe" is OK but "foo" is an error.
13842   #
13843   # This test is therefore slightly more accurate than "test -f" to check for file precense.
13844   # It is also a way to make sure we got the proper file name for the real test later on.
13845   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
13846   if test "x$test_shortpath" = x; then
13847     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of SRC_ROOT, which resolves as \"$path\", is invalid." >&5
13848 $as_echo "$as_me: The path of SRC_ROOT, which resolves as \"$path\", is invalid." >&6;}
13849     as_fn_error $? "Cannot locate the the path of SRC_ROOT" "$LINENO" 5
13850   fi
13851 
13852   # Call helper function which possibly converts this using DOS-style short mode.
13853   # If so, the updated path is stored in $new_path.
13854 
13855   input_path="$new_path"
13856   # Check if we need to convert this using DOS-style short mode. If the path
13857   # contains just simple characters, use it. Otherwise (spaces, weird characters),
13858   # take no chances and rewrite it.
13859   # Note: m4 eats our [], so we need to use [ and ] instead.
13860   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
13861   if test "x$has_forbidden_chars" != x; then
13862     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
13863     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
13864     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
13865     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
13866       # Going to short mode and back again did indeed matter. Since short mode is
13867       # case insensitive, let's make it lowercase to improve readability.
13868       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
13869       # Now convert it back to Unix-stile (cygpath)
13870       input_path=`$CYGPATH -u "$shortmode_path"`
13871       new_path="$input_path"
13872     fi
13873   fi
13874 
13875   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
13876   if test "x$test_cygdrive_prefix" = x; then
13877     # As a simple fix, exclude /usr/bin since it's not a real path.
13878     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
13879       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
13880       # a path prefixed by /cygdrive for fixpath to work.
13881       new_path="$CYGWIN_ROOT_PATH$input_path"
13882     fi
13883   fi
13884 
13885 
13886   if test "x$path" != "x$new_path"; then
13887     SRC_ROOT="$new_path"
13888     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting SRC_ROOT to \"$new_path\"" >&5
13889 $as_echo "$as_me: Rewriting SRC_ROOT to \"$new_path\"" >&6;}
13890   fi
13891 
13892   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
13893 
13894   path="$SRC_ROOT"
13895   has_colon=`$ECHO $path | $GREP ^.:`
13896   new_path="$path"
13897   if test "x$has_colon" = x; then
13898     # Not in mixed or Windows style, start by that.
13899     new_path=`cmd //c echo $path`
13900   fi
13901 
13902 
13903   input_path="$new_path"
13904   # Check if we need to convert this using DOS-style short mode. If the path
13905   # contains just simple characters, use it. Otherwise (spaces, weird characters),
13906   # take no chances and rewrite it.
13907   # Note: m4 eats our [], so we need to use [ and ] instead.
13908   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
13909   if test "x$has_forbidden_chars" != x; then
13910     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
13911     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
13912   fi
13913 
13914 
13915   windows_path="$new_path"
13916   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13917     unix_path=`$CYGPATH -u "$windows_path"`
13918     new_path="$unix_path"
13919   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
13920     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
13921     new_path="$unix_path"
13922   fi
13923 
13924   if test "x$path" != "x$new_path"; then
13925     SRC_ROOT="$new_path"
13926     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting SRC_ROOT to \"$new_path\"" >&5
13927 $as_echo "$as_me: Rewriting SRC_ROOT to \"$new_path\"" >&6;}
13928   fi
13929 
13930   # Save the first 10 bytes of this path to the storage, so fixpath can work.
13931   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
13932 
13933   else
13934     # We're on a posix platform. Hooray! :)
13935     path="$SRC_ROOT"
13936     has_space=`$ECHO "$path" | $GREP " "`
13937     if test "x$has_space" != x; then
13938       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of SRC_ROOT, which resolves as \"$path\", is invalid." >&5
13939 $as_echo "$as_me: The path of SRC_ROOT, which resolves as \"$path\", is invalid." >&6;}
13940       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
13941     fi
13942 
13943     # Use eval to expand a potential ~
13944     eval path="$path"
13945     if test ! -f "$path" && test ! -d "$path"; then
13946       as_fn_error $? "The path of SRC_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
13947     fi
13948 
13949     SRC_ROOT="`cd "$path"; $THEPWDCMD -L`"
13950   fi
13951 
13952 
13953   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13954 
13955   # Input might be given as Windows format, start by converting to
13956   # unix format.
13957   path="$CURDIR"
13958   new_path=`$CYGPATH -u "$path"`
13959 
13960   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
13961   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
13962   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
13963   # "foo.exe" is OK but "foo" is an error.
13964   #
13965   # This test is therefore slightly more accurate than "test -f" to check for file precense.
13966   # It is also a way to make sure we got the proper file name for the real test later on.
13967   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
13968   if test "x$test_shortpath" = x; then
13969     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
13970 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
13971     as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
13972   fi
13973 
13974   # Call helper function which possibly converts this using DOS-style short mode.
13975   # If so, the updated path is stored in $new_path.
13976 
13977   input_path="$new_path"
13978   # Check if we need to convert this using DOS-style short mode. If the path
13979   # contains just simple characters, use it. Otherwise (spaces, weird characters),
13980   # take no chances and rewrite it.
13981   # Note: m4 eats our [], so we need to use [ and ] instead.
13982   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
13983   if test "x$has_forbidden_chars" != x; then
13984     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
13985     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
13986     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
13987     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
13988       # Going to short mode and back again did indeed matter. Since short mode is
13989       # case insensitive, let's make it lowercase to improve readability.
13990       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
13991       # Now convert it back to Unix-stile (cygpath)
13992       input_path=`$CYGPATH -u "$shortmode_path"`
13993       new_path="$input_path"
13994     fi
13995   fi
13996 
13997   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
13998   if test "x$test_cygdrive_prefix" = x; then
13999     # As a simple fix, exclude /usr/bin since it's not a real path.
14000     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14001       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14002       # a path prefixed by /cygdrive for fixpath to work.
14003       new_path="$CYGWIN_ROOT_PATH$input_path"
14004     fi
14005   fi
14006 
14007 
14008   if test "x$path" != "x$new_path"; then
14009     CURDIR="$new_path"
14010     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14011 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14012   fi
14013 
14014   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14015 
14016   path="$CURDIR"
14017   has_colon=`$ECHO $path | $GREP ^.:`
14018   new_path="$path"
14019   if test "x$has_colon" = x; then
14020     # Not in mixed or Windows style, start by that.
14021     new_path=`cmd //c echo $path`
14022   fi
14023 
14024 
14025   input_path="$new_path"
14026   # Check if we need to convert this using DOS-style short mode. If the path
14027   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14028   # take no chances and rewrite it.
14029   # Note: m4 eats our [], so we need to use [ and ] instead.
14030   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14031   if test "x$has_forbidden_chars" != x; then
14032     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14033     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14034   fi
14035 
14036 
14037   windows_path="$new_path"
14038   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14039     unix_path=`$CYGPATH -u "$windows_path"`
14040     new_path="$unix_path"
14041   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14042     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14043     new_path="$unix_path"
14044   fi
14045 
14046   if test "x$path" != "x$new_path"; then
14047     CURDIR="$new_path"
14048     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14049 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14050   fi
14051 
14052   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14053   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14054 
14055   else
14056     # We're on a posix platform. Hooray! :)
14057     path="$CURDIR"
14058     has_space=`$ECHO "$path" | $GREP " "`
14059     if test "x$has_space" != x; then
14060       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14061 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14062       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14063     fi
14064 
14065     # Use eval to expand a potential ~
14066     eval path="$path"
14067     if test ! -f "$path" && test ! -d "$path"; then
14068       as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14069     fi
14070 
14071     CURDIR="`cd "$path"; $THEPWDCMD -L`"
14072   fi
14073 
14074 
14075   if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
14076     # Add extra search paths on solaris for utilities like ar and as etc...
14077     PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin"
14078   fi
14079 
14080   # You can force the sys-root if the sys-root encoded into the cross compiler tools
14081   # is not correct.
14082 
14083 # Check whether --with-sys-root was given.
14084 if test "${with_sys_root+set}" = set; then :
14085   withval=$with_sys_root;
14086 fi
14087 
14088 
14089   if test "x$with_sys_root" != x; then
14090     SYS_ROOT=$with_sys_root
14091   else
14092     SYS_ROOT=/
14093   fi
14094 
14095 
14096 
14097 # Check whether --with-tools-dir was given.
14098 if test "${with_tools_dir+set}" = set; then :
14099   withval=$with_tools_dir; TOOLS_DIR=$with_tools_dir
14100 
14101 fi
14102 
14103 
14104 
14105 # Check whether --with-devkit was given.
14106 if test "${with_devkit+set}" = set; then :
14107   withval=$with_devkit;
14108         if test "x$with_sys_root" != x; then
14109           as_fn_error $? "Cannot specify both --with-devkit and --with-sys-root at the same time" "$LINENO" 5
14110         fi
14111 
14112   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14113 
14114   # Input might be given as Windows format, start by converting to
14115   # unix format.
14116   path="$with_devkit"
14117   new_path=`$CYGPATH -u "$path"`
14118 
14119   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14120   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14121   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14122   # "foo.exe" is OK but "foo" is an error.
14123   #
14124   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14125   # It is also a way to make sure we got the proper file name for the real test later on.
14126   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14127   if test "x$test_shortpath" = x; then
14128     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14129 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14130     as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
14131   fi
14132 
14133   # Call helper function which possibly converts this using DOS-style short mode.
14134   # If so, the updated path is stored in $new_path.
14135 
14136   input_path="$new_path"
14137   # Check if we need to convert this using DOS-style short mode. If the path
14138   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14139   # take no chances and rewrite it.
14140   # Note: m4 eats our [], so we need to use [ and ] instead.
14141   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14142   if test "x$has_forbidden_chars" != x; then
14143     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14144     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14145     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14146     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14147       # Going to short mode and back again did indeed matter. Since short mode is
14148       # case insensitive, let's make it lowercase to improve readability.
14149       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14150       # Now convert it back to Unix-stile (cygpath)
14151       input_path=`$CYGPATH -u "$shortmode_path"`
14152       new_path="$input_path"
14153     fi
14154   fi
14155 
14156   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14157   if test "x$test_cygdrive_prefix" = x; then
14158     # As a simple fix, exclude /usr/bin since it's not a real path.
14159     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14160       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14161       # a path prefixed by /cygdrive for fixpath to work.
14162       new_path="$CYGWIN_ROOT_PATH$input_path"
14163     fi
14164   fi
14165 
14166 
14167   if test "x$path" != "x$new_path"; then
14168     with_devkit="$new_path"
14169     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14170 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14171   fi
14172 
14173   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14174 
14175   path="$with_devkit"
14176   has_colon=`$ECHO $path | $GREP ^.:`
14177   new_path="$path"
14178   if test "x$has_colon" = x; then
14179     # Not in mixed or Windows style, start by that.
14180     new_path=`cmd //c echo $path`
14181   fi
14182 
14183 
14184   input_path="$new_path"
14185   # Check if we need to convert this using DOS-style short mode. If the path
14186   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14187   # take no chances and rewrite it.
14188   # Note: m4 eats our [], so we need to use [ and ] instead.
14189   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14190   if test "x$has_forbidden_chars" != x; then
14191     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14192     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14193   fi
14194 
14195 
14196   windows_path="$new_path"
14197   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14198     unix_path=`$CYGPATH -u "$windows_path"`
14199     new_path="$unix_path"
14200   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14201     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14202     new_path="$unix_path"
14203   fi
14204 
14205   if test "x$path" != "x$new_path"; then
14206     with_devkit="$new_path"
14207     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14208 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14209   fi
14210 
14211   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14212   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14213 
14214   else
14215     # We're on a posix platform. Hooray! :)
14216     path="$with_devkit"
14217     has_space=`$ECHO "$path" | $GREP " "`
14218     if test "x$has_space" != x; then
14219       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14220 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14221       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14222     fi
14223 
14224     # Use eval to expand a potential ~
14225     eval path="$path"
14226     if test ! -f "$path" && test ! -d "$path"; then
14227       as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
14228     fi
14229 
14230     with_devkit="`cd "$path"; $THEPWDCMD -L`"
14231   fi
14232 
14233 
14234   if test "x$TOOLS_DIR" = x; then
14235     TOOLS_DIR="$with_devkit/bin"
14236   else
14237     TOOLS_DIR="$TOOLS_DIR:$with_devkit/bin"
14238   fi
14239 
14240         if test -d "$with_devkit/$host_alias/libc"; then
14241           SYS_ROOT=$with_devkit/$host_alias/libc
14242         elif test -d "$with_devkit/$host/sys-root"; then
14243           SYS_ROOT=$with_devkit/$host/sys-root
14244         fi
14245 
14246 fi
14247 
14248 
14249 
14250   # Setup default logging of stdout and stderr to build.log in the output root.
14251   BUILD_LOG='$(OUTPUT_ROOT)/build.log'
14252   BUILD_LOG_PREVIOUS='$(OUTPUT_ROOT)/build.log.old'
14253   BUILD_LOG_WRAPPER='$(BASH) $(SRC_ROOT)/common/bin/logger.sh $(BUILD_LOG)'
14254 
14255 
14256 
14257 
14258 
14259 # Check if it's a pure open build or if custom sources are to be used.
14260 
14261   # Check whether --enable-openjdk-only was given.
14262 if test "${enable_openjdk_only+set}" = set; then :
14263   enableval=$enable_openjdk_only;
14264 else
14265   enable_openjdk_only="no"
14266 fi
14267 
14268 
14269   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
14270 $as_echo_n "checking for presence of closed sources... " >&6; }
14271   if test -d "$SRC_ROOT/jdk/src/closed"; then
14272     CLOSED_SOURCE_PRESENT=yes
14273   else
14274     CLOSED_SOURCE_PRESENT=no
14275   fi
14276   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
14277 $as_echo "$CLOSED_SOURCE_PRESENT" >&6; }
14278 
14279   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
14280 $as_echo_n "checking if closed source is suppressed (openjdk-only)... " >&6; }
14281   SUPPRESS_CLOSED_SOURCE="$enable_openjdk_only"
14282   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
14283 $as_echo "$SUPPRESS_CLOSED_SOURCE" >&6; }
14284 
14285   if test "x$CLOSED_SOURCE_PRESENT" = xno; then
14286     OPENJDK=true
14287     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14288       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
14289 $as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
14290     fi
14291   else
14292     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14293       OPENJDK=true
14294     else
14295       OPENJDK=false
14296     fi
14297   fi
14298 
14299   if test "x$OPENJDK" = "xtrue"; then
14300     SET_OPENJDK="OPENJDK=true"
14301   fi
14302 
14303 
14304 
14305 
14306 # These are needed to be able to create a configuration name (and thus the output directory)
14307 
14308   ###############################################################################
14309   #
14310   # Check which variant of the JDK that we want to build.
14311   # Currently we have:
14312   #    normal:   standard edition
14313   # but the custom make system may add other variants
14314   #
14315   # Effectively the JDK variant gives a name to a specific set of
14316   # modules to compile into the JDK. In the future, these modules
14317   # might even be Jigsaw modules.
14318   #
14319   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
14320 $as_echo_n "checking which variant of the JDK to build... " >&6; }
14321 
14322 # Check whether --with-jdk-variant was given.
14323 if test "${with_jdk_variant+set}" = set; then :
14324   withval=$with_jdk_variant;
14325 fi
14326 
14327 
14328   if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
14329     JDK_VARIANT="normal"
14330   else
14331     as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
14332   fi
14333 
14334 
14335 
14336   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
14337 $as_echo "$JDK_VARIANT" >&6; }
14338 
14339 
14340 ###############################################################################
14341 #
14342 # Check which interpreter of the JVM we want to build.
14343 # Currently we have:
14344 #    template: Template interpreter (the default)
14345 #    cpp     : C++ interpreter
14346 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which interpreter of the JVM to build" >&5
14347 $as_echo_n "checking which interpreter of the JVM to build... " >&6; }
14348 
14349 # Check whether --with-jvm-interpreter was given.
14350 if test "${with_jvm_interpreter+set}" = set; then :
14351   withval=$with_jvm_interpreter;
14352 fi
14353 
14354 
14355 if test "x$with_jvm_interpreter" = x; then
14356      with_jvm_interpreter="template"
14357 fi
14358 
14359 JVM_INTERPRETER="$with_jvm_interpreter"
14360 
14361 if test "x$JVM_INTERPRETER" != xtemplate && test "x$JVM_INTERPRETER" != xcpp; then
14362    as_fn_error $? "The available JVM interpreters are: template, cpp" "$LINENO" 5
14363 fi
14364 
14365 
14366 
14367 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_interpreter" >&5
14368 $as_echo "$with_jvm_interpreter" >&6; }
14369 
14370 
14371 
14372   ###############################################################################
14373   #
14374   # Check which variants of the JVM that we want to build.
14375   # Currently we have:
14376   #    server: normal interpreter and a tiered C1/C2 compiler
14377   #    client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms)
14378   #    minimal1: reduced form of client with optional VM services and features stripped out
14379   #    kernel: kernel footprint JVM that passes the TCK without major performance problems,
14380   #             ie normal interpreter and C1, only the serial GC, kernel jvmti etc
14381   #    zero: no machine code interpreter, no compiler
14382   #    zeroshark: zero interpreter and shark/llvm compiler backend
14383 #    core: interpreter only, no compiler (only works on some platforms)
14384   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
14385 $as_echo_n "checking which variants of the JVM to build... " >&6; }
14386 
14387 # Check whether --with-jvm-variants was given.
14388 if test "${with_jvm_variants+set}" = set; then :
14389   withval=$with_jvm_variants;
14390 fi
14391 
14392 
14393   if test "x$with_jvm_variants" = x; then
14394     with_jvm_variants="server"
14395   fi
14396 
14397   JVM_VARIANTS=",$with_jvm_variants,"
14398   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,//'`
14399 
14400   if test "x$TEST_VARIANTS" != "x,"; then
14401      as_fn_error $? "The available JVM variants are: server, client, minimal1, kernel, zero, zeroshark, core" "$LINENO" 5
14402   fi
14403   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5
14404 $as_echo "$with_jvm_variants" >&6; }
14405 
14406   JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'`
14407   JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'`
14408   JVM_VARIANT_MINIMAL1=`$ECHO "$JVM_VARIANTS" | $SED -e '/,minimal1,/!s/.*/false/g' -e '/,minimal1,/s/.*/true/g'`
14409   JVM_VARIANT_KERNEL=`$ECHO "$JVM_VARIANTS" | $SED -e '/,kernel,/!s/.*/false/g' -e '/,kernel,/s/.*/true/g'`
14410   JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'`
14411   JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'`
14412   JVM_VARIANT_CORE=`$ECHO "$JVM_VARIANTS" | $SED -e '/,core,/!s/.*/false/g' -e '/,core,/s/.*/true/g'`
14413 
14414   if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14415     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14416       as_fn_error $? "You cannot build a client JVM for a 64-bit machine." "$LINENO" 5
14417     fi
14418   fi
14419   if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14420     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14421       as_fn_error $? "You cannot build a kernel JVM for a 64-bit machine." "$LINENO" 5
14422     fi
14423   fi
14424   if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14425     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14426       as_fn_error $? "You cannot build a minimal JVM for a 64-bit machine." "$LINENO" 5
14427     fi
14428   fi
14429 
14430   # Replace the commas with AND for use in the build directory name.
14431   ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/g'`
14432   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/'`
14433   if test "x$COUNT_VARIANTS" != "x,1"; then
14434     BUILDING_MULTIPLE_JVM_VARIANTS=yes
14435   else
14436     BUILDING_MULTIPLE_JVM_VARIANTS=no
14437   fi
14438 
14439 
14440 
14441 
14442 
14443 
14444 
14445 
14446 
14447 
14448   INCLUDE_SA=true
14449   if test "x$JVM_VARIANT_ZERO" = xtrue ; then
14450     INCLUDE_SA=false
14451   fi
14452   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue ; then
14453     INCLUDE_SA=false
14454   fi
14455   if test "x$VAR_CPU" = xppc64 ; then
14456     INCLUDE_SA=false
14457   fi
14458 
14459 
14460   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
14461     MACOSX_UNIVERSAL="true"
14462   fi
14463 
14464 
14465 
14466 
14467   ###############################################################################
14468   #
14469   # Set the debug level
14470   #    release: no debug information, all optimizations, no asserts.
14471   #    fastdebug: debug information (-g), all optimizations, all asserts
14472   #    slowdebug: debug information (-g), no optimizations, all asserts
14473   #
14474   DEBUG_LEVEL="release"
14475   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
14476 $as_echo_n "checking which debug level to use... " >&6; }
14477   # Check whether --enable-debug was given.
14478 if test "${enable_debug+set}" = set; then :
14479   enableval=$enable_debug;
14480         ENABLE_DEBUG="${enableval}"
14481         DEBUG_LEVEL="fastdebug"
14482 
14483 else
14484   ENABLE_DEBUG="no"
14485 fi
14486 
14487 
14488 
14489 # Check whether --with-debug-level was given.
14490 if test "${with_debug_level+set}" = set; then :
14491   withval=$with_debug_level;
14492         DEBUG_LEVEL="${withval}"
14493         if test "x$ENABLE_DEBUG" = xyes; then
14494           as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
14495         fi
14496 
14497 fi
14498 
14499   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
14500 $as_echo "$DEBUG_LEVEL" >&6; }
14501 
14502   if test "x$DEBUG_LEVEL" != xrelease && \
14503       test "x$DEBUG_LEVEL" != xfastdebug && \
14504       test "x$DEBUG_LEVEL" != xslowdebug; then
14505     as_fn_error $? "Allowed debug levels are: release, fastdebug and slowdebug" "$LINENO" 5
14506   fi
14507 
14508 
14509   ###############################################################################
14510   #
14511   # Setup legacy vars/targets and new vars to deal with different debug levels.
14512   #
14513 
14514   case $DEBUG_LEVEL in
14515     release )
14516       VARIANT="OPT"
14517       FASTDEBUG="false"
14518       DEBUG_CLASSFILES="false"
14519       BUILD_VARIANT_RELEASE=""
14520       HOTSPOT_DEBUG_LEVEL="product"
14521       HOTSPOT_EXPORT="product"
14522       ;;
14523     fastdebug )
14524       VARIANT="DBG"
14525       FASTDEBUG="true"
14526       DEBUG_CLASSFILES="true"
14527       BUILD_VARIANT_RELEASE="-fastdebug"
14528       HOTSPOT_DEBUG_LEVEL="fastdebug"
14529       HOTSPOT_EXPORT="fastdebug"
14530       ;;
14531     slowdebug )
14532       VARIANT="DBG"
14533       FASTDEBUG="false"
14534       DEBUG_CLASSFILES="true"
14535       BUILD_VARIANT_RELEASE="-debug"
14536       HOTSPOT_DEBUG_LEVEL="jvmg"
14537       HOTSPOT_EXPORT="debug"
14538       ;;
14539   esac
14540 
14541   #####
14542   # Generate the legacy makefile targets for hotspot.
14543   # The hotspot api for selecting the build artifacts, really, needs to be improved.
14544   # JDK-7195896 will fix this on the hotspot side by using the JVM_VARIANT_* variables to
14545   # determine what needs to be built. All we will need to set here is all_product, all_fastdebug etc
14546   # But until then ...
14547   HOTSPOT_TARGET=""
14548 
14549   if test "x$JVM_VARIANT_SERVER" = xtrue; then
14550     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL} "
14551   fi
14552 
14553   if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14554     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}1 "
14555   fi
14556 
14557   if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14558     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}minimal1 "
14559   fi
14560 
14561   if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14562     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}kernel "
14563   fi
14564 
14565   if test "x$JVM_VARIANT_ZERO" = xtrue; then
14566     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}zero "
14567   fi
14568 
14569   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
14570     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}shark "
14571   fi
14572 
14573   if test "x$JVM_VARIANT_CORE" = xtrue; then
14574     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}core "
14575   fi
14576 
14577   HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT"
14578 
14579   # On Macosx universal binaries are produced, but they only contain
14580   # 64 bit intel. This invalidates control of which jvms are built
14581   # from configure, but only server is valid anyway. Fix this
14582   # when hotspot makefiles are rewritten.
14583   if test "x$MACOSX_UNIVERSAL" = xtrue; then
14584     HOTSPOT_TARGET=universal_${HOTSPOT_EXPORT}
14585   fi
14586 
14587   #####
14588 
14589 
14590 
14591 
14592 
14593 
14594 
14595 
14596 # With basic setup done, call the custom early hook.
14597 
14598 
14599 # To properly create a configuration name, we need to have the OpenJDK target
14600 # and options (variants and debug level) parsed.
14601 
14602 
14603 
14604 # Check whether --with-conf-name was given.
14605 if test "${with_conf_name+set}" = set; then :
14606   withval=$with_conf_name;  CONF_NAME=${with_conf_name}
14607 fi
14608 
14609 
14610   # Test from where we are running configure, in or outside of src root.
14611   if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
14612       || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
14613       || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
14614     # We are running configure from the src root.
14615     # Create a default ./build/target-variant-debuglevel output root.
14616     if test "x${CONF_NAME}" = x; then
14617       CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}"
14618     fi
14619     OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
14620     $MKDIR -p "$OUTPUT_ROOT"
14621     if test ! -d "$OUTPUT_ROOT"; then
14622       as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
14623     fi
14624   else
14625     # We are running configure from outside of the src dir.
14626     # Then use the current directory as output dir!
14627     # If configuration is situated in normal build directory, just use the build
14628     # directory name as configuration name, otherwise use the complete path.
14629     if test "x${CONF_NAME}" = x; then
14630       CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
14631     fi
14632     OUTPUT_ROOT="$CURDIR"
14633 
14634     # WARNING: This might be a bad thing to do. You need to be sure you want to
14635     # have a configuration in this directory. Do some sanity checks!
14636 
14637     if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
14638       # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
14639       # other files
14640       files_present=`$LS $OUTPUT_ROOT`
14641       # Configure has already touched config.log and confdefs.h in the current dir when this check
14642       # is performed.
14643       filtered_files=`$ECHO "$files_present" | $SED -e 's/config.log//g' -e 's/confdefs.h//g' -e 's/ //g' \
14644       | $TR -d '\n'`
14645       if test "x$filtered_files" != x; then
14646         { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
14647 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
14648         { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
14649 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
14650         { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
14651 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
14652         { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
14653 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
14654         { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
14655 $as_echo "$as_me: seriously mess up just about everything." >&6;}
14656         { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
14657 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
14658         { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
14659 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
14660         as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
14661       fi
14662     fi
14663   fi
14664   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
14665 $as_echo_n "checking what configuration name to use... " >&6; }
14666   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
14667 $as_echo "$CONF_NAME" >&6; }
14668 
14669 
14670   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14671 
14672   # Input might be given as Windows format, start by converting to
14673   # unix format.
14674   path="$OUTPUT_ROOT"
14675   new_path=`$CYGPATH -u "$path"`
14676 
14677   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14678   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14679   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14680   # "foo.exe" is OK but "foo" is an error.
14681   #
14682   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14683   # It is also a way to make sure we got the proper file name for the real test later on.
14684   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14685   if test "x$test_shortpath" = x; then
14686     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
14687 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
14688     as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
14689   fi
14690 
14691   # Call helper function which possibly converts this using DOS-style short mode.
14692   # If so, the updated path is stored in $new_path.
14693 
14694   input_path="$new_path"
14695   # Check if we need to convert this using DOS-style short mode. If the path
14696   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14697   # take no chances and rewrite it.
14698   # Note: m4 eats our [], so we need to use [ and ] instead.
14699   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14700   if test "x$has_forbidden_chars" != x; then
14701     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14702     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14703     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14704     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14705       # Going to short mode and back again did indeed matter. Since short mode is
14706       # case insensitive, let's make it lowercase to improve readability.
14707       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14708       # Now convert it back to Unix-stile (cygpath)
14709       input_path=`$CYGPATH -u "$shortmode_path"`
14710       new_path="$input_path"
14711     fi
14712   fi
14713 
14714   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14715   if test "x$test_cygdrive_prefix" = x; then
14716     # As a simple fix, exclude /usr/bin since it's not a real path.
14717     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14718       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14719       # a path prefixed by /cygdrive for fixpath to work.
14720       new_path="$CYGWIN_ROOT_PATH$input_path"
14721     fi
14722   fi
14723 
14724 
14725   if test "x$path" != "x$new_path"; then
14726     OUTPUT_ROOT="$new_path"
14727     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
14728 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
14729   fi
14730 
14731   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14732 
14733   path="$OUTPUT_ROOT"
14734   has_colon=`$ECHO $path | $GREP ^.:`
14735   new_path="$path"
14736   if test "x$has_colon" = x; then
14737     # Not in mixed or Windows style, start by that.
14738     new_path=`cmd //c echo $path`
14739   fi
14740 
14741 
14742   input_path="$new_path"
14743   # Check if we need to convert this using DOS-style short mode. If the path
14744   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14745   # take no chances and rewrite it.
14746   # Note: m4 eats our [], so we need to use [ and ] instead.
14747   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14748   if test "x$has_forbidden_chars" != x; then
14749     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14750     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14751   fi
14752 
14753 
14754   windows_path="$new_path"
14755   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14756     unix_path=`$CYGPATH -u "$windows_path"`
14757     new_path="$unix_path"
14758   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14759     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14760     new_path="$unix_path"
14761   fi
14762 
14763   if test "x$path" != "x$new_path"; then
14764     OUTPUT_ROOT="$new_path"
14765     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
14766 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
14767   fi
14768 
14769   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14770   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14771 
14772   else
14773     # We're on a posix platform. Hooray! :)
14774     path="$OUTPUT_ROOT"
14775     has_space=`$ECHO "$path" | $GREP " "`
14776     if test "x$has_space" != x; then
14777       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
14778 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
14779       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14780     fi
14781 
14782     # Use eval to expand a potential ~
14783     eval path="$path"
14784     if test ! -f "$path" && test ! -d "$path"; then
14785       as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
14786     fi
14787 
14788     OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
14789   fi
14790 
14791 
14792   SPEC=$OUTPUT_ROOT/spec.gmk
14793 
14794   CONF_NAME=$CONF_NAME
14795 
14796   OUTPUT_ROOT=$OUTPUT_ROOT
14797 
14798 
14799   # Most of the probed defines are put into config.h
14800   ac_config_headers="$ac_config_headers $OUTPUT_ROOT/config.h:$AUTOCONF_DIR/config.h.in"
14801 
14802   # The spec.gmk file contains all variables for the make system.
14803   ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
14804 
14805   # The hotspot-spec.gmk file contains legacy variables for the hotspot make system.
14806   ac_config_files="$ac_config_files $OUTPUT_ROOT/hotspot-spec.gmk:$AUTOCONF_DIR/hotspot-spec.gmk.in"
14807 
14808   # The bootcycle-spec.gmk file contains support for boot cycle builds.
14809   ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
14810 
14811   # The compare.sh is used to compare the build output to other builds.
14812   ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
14813 
14814   # Spec.sh is currently used by compare-objects.sh
14815   ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.sh:$AUTOCONF_DIR/spec.sh.in"
14816 
14817   # The generated Makefile knows where the spec.gmk is and where the source is.
14818   # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
14819   # which will look for generated configurations
14820   ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
14821 
14822 
14823   # Save the arguments given to us
14824   echo "$CONFIGURE_COMMAND_LINE" > $OUTPUT_ROOT/configure-arguments
14825 
14826 
14827 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
14828 
14829   for ac_prog in apt-get yum port pkgutil pkgadd
14830 do
14831   # Extract the first word of "$ac_prog", so it can be a program name with args.
14832 set dummy $ac_prog; ac_word=$2
14833 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
14834 $as_echo_n "checking for $ac_word... " >&6; }
14835 if ${ac_cv_prog_PKGHANDLER+:} false; then :
14836   $as_echo_n "(cached) " >&6
14837 else
14838   if test -n "$PKGHANDLER"; then
14839   ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
14840 else
14841 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14842 for as_dir in $PATH
14843 do
14844   IFS=$as_save_IFS
14845   test -z "$as_dir" && as_dir=.
14846     for ac_exec_ext in '' $ac_executable_extensions; do
14847   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14848     ac_cv_prog_PKGHANDLER="$ac_prog"
14849     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
14850     break 2
14851   fi
14852 done
14853   done
14854 IFS=$as_save_IFS
14855 
14856 fi
14857 fi
14858 PKGHANDLER=$ac_cv_prog_PKGHANDLER
14859 if test -n "$PKGHANDLER"; then
14860   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
14861 $as_echo "$PKGHANDLER" >&6; }
14862 else
14863   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
14864 $as_echo "no" >&6; }
14865 fi
14866 
14867 
14868   test -n "$PKGHANDLER" && break
14869 done
14870 
14871 
14872 
14873 # Setup tools that requires more complex handling, or that is not needed by the configure script.
14874 
14875 
14876   # We need to find a recent version of GNU make. Especially on Solaris, this can be tricky.
14877   if test "x$MAKE" != x; then
14878     # User has supplied a make, test it.
14879     if test ! -f "$MAKE"; then
14880       as_fn_error $? "The specified make (by MAKE=$MAKE) is not found." "$LINENO" 5
14881     fi
14882 
14883   MAKE_CANDIDATE=""$MAKE""
14884   DESCRIPTION="user supplied MAKE=$MAKE"
14885   if test "x$MAKE_CANDIDATE" != x; then
14886     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
14887 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
14888     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
14889     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
14890     if test "x$IS_GNU_MAKE" = x; then
14891       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
14892 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
14893     else
14894       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
14895       if test "x$IS_MODERN_MAKE" = x; then
14896         { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
14897 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
14898       else
14899         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
14900           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14901             MAKE_EXPECTED_ENV='cygwin'
14902           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14903             MAKE_EXPECTED_ENV='msys'
14904           else
14905             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
14906           fi
14907           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
14908           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
14909         else
14910           # Not relevant for non-Windows
14911           IS_MAKE_CORRECT_ENV=true
14912         fi
14913         if test "x$IS_MAKE_CORRECT_ENV" = x; then
14914           { $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
14915 $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;}
14916         else
14917           FOUND_MAKE=$MAKE_CANDIDATE
14918 
14919   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14920 
14921   # First separate the path from the arguments. This will split at the first
14922   # space.
14923   complete="$FOUND_MAKE"
14924   path="${complete%% *}"
14925   tmp="$complete EOL"
14926   arguments="${tmp#* }"
14927 
14928   # Input might be given as Windows format, start by converting to
14929   # unix format.
14930   new_path=`$CYGPATH -u "$path"`
14931 
14932   # Now try to locate executable using which
14933   new_path=`$WHICH "$new_path" 2> /dev/null`
14934   # bat and cmd files are not always considered executable in cygwin causing which
14935   # to not find them
14936   if test "x$new_path" = x \
14937       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
14938       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
14939     new_path=`$CYGPATH -u "$path"`
14940   fi
14941   if test "x$new_path" = x; then
14942     # Oops. Which didn't find the executable.
14943     # The splitting of arguments from the executable at a space might have been incorrect,
14944     # since paths with space are more likely in Windows. Give it another try with the whole
14945     # argument.
14946     path="$complete"
14947     arguments="EOL"
14948     new_path=`$CYGPATH -u "$path"`
14949     new_path=`$WHICH "$new_path" 2> /dev/null`
14950     # bat and cmd files are not always considered executable in cygwin causing which
14951     # to not find them
14952     if test "x$new_path" = x \
14953         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
14954         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
14955       new_path=`$CYGPATH -u "$path"`
14956     fi
14957     if test "x$new_path" = x; then
14958       # It's still not found. Now this is an unrecoverable error.
14959       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
14960 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
14961       has_space=`$ECHO "$complete" | $GREP " "`
14962       if test "x$has_space" != x; then
14963         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
14964 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
14965       fi
14966       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
14967     fi
14968   fi
14969 
14970   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14971   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14972   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14973   # "foo.exe" is OK but "foo" is an error.
14974   #
14975   # This test is therefore slightly more accurate than "test -f" to check for file presence.
14976   # It is also a way to make sure we got the proper file name for the real test later on.
14977   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14978   if test "x$test_shortpath" = x; then
14979     # Short path failed, file does not exist as specified.
14980     # Try adding .exe or .cmd
14981     if test -f "${new_path}.exe"; then
14982       input_to_shortpath="${new_path}.exe"
14983     elif test -f "${new_path}.cmd"; then
14984       input_to_shortpath="${new_path}.cmd"
14985     else
14986       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
14987 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
14988       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
14989 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
14990       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
14991     fi
14992   else
14993     input_to_shortpath="$new_path"
14994   fi
14995 
14996   # Call helper function which possibly converts this using DOS-style short mode.
14997   # If so, the updated path is stored in $new_path.
14998   new_path="$input_to_shortpath"
14999 
15000   input_path="$input_to_shortpath"
15001   # Check if we need to convert this using DOS-style short mode. If the path
15002   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15003   # take no chances and rewrite it.
15004   # Note: m4 eats our [], so we need to use [ and ] instead.
15005   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15006   if test "x$has_forbidden_chars" != x; then
15007     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15008     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15009     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15010     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15011       # Going to short mode and back again did indeed matter. Since short mode is
15012       # case insensitive, let's make it lowercase to improve readability.
15013       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15014       # Now convert it back to Unix-stile (cygpath)
15015       input_path=`$CYGPATH -u "$shortmode_path"`
15016       new_path="$input_path"
15017     fi
15018   fi
15019 
15020   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15021   if test "x$test_cygdrive_prefix" = x; then
15022     # As a simple fix, exclude /usr/bin since it's not a real path.
15023     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15024       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15025       # a path prefixed by /cygdrive for fixpath to work.
15026       new_path="$CYGWIN_ROOT_PATH$input_path"
15027     fi
15028   fi
15029 
15030   # remove trailing .exe if any
15031   new_path="${new_path/%.exe/}"
15032 
15033   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15034 
15035   # First separate the path from the arguments. This will split at the first
15036   # space.
15037   complete="$FOUND_MAKE"
15038   path="${complete%% *}"
15039   tmp="$complete EOL"
15040   arguments="${tmp#* }"
15041 
15042   # Input might be given as Windows format, start by converting to
15043   # unix format.
15044   new_path="$path"
15045 
15046   windows_path="$new_path"
15047   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15048     unix_path=`$CYGPATH -u "$windows_path"`
15049     new_path="$unix_path"
15050   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15051     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15052     new_path="$unix_path"
15053   fi
15054 
15055 
15056   # Now try to locate executable using which
15057   new_path=`$WHICH "$new_path" 2> /dev/null`
15058 
15059   if test "x$new_path" = x; then
15060     # Oops. Which didn't find the executable.
15061     # The splitting of arguments from the executable at a space might have been incorrect,
15062     # since paths with space are more likely in Windows. Give it another try with the whole
15063     # argument.
15064     path="$complete"
15065     arguments="EOL"
15066     new_path="$path"
15067 
15068   windows_path="$new_path"
15069   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15070     unix_path=`$CYGPATH -u "$windows_path"`
15071     new_path="$unix_path"
15072   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15073     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15074     new_path="$unix_path"
15075   fi
15076 
15077 
15078     new_path=`$WHICH "$new_path" 2> /dev/null`
15079 
15080     if test "x$new_path" = x; then
15081       # It's still not found. Now this is an unrecoverable error.
15082       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15083 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15084       has_space=`$ECHO "$complete" | $GREP " "`
15085       if test "x$has_space" != x; then
15086         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15087 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15088       fi
15089       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15090     fi
15091   fi
15092 
15093   # Now new_path has a complete unix path to the binary
15094   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15095     # Keep paths in /bin as-is, but remove trailing .exe if any
15096     new_path="${new_path/%.exe/}"
15097     # Do not save /bin paths to all_fixpath_prefixes!
15098   else
15099     # Not in mixed or Windows style, start by that.
15100     new_path=`cmd //c echo $new_path`
15101 
15102   input_path="$new_path"
15103   # Check if we need to convert this using DOS-style short mode. If the path
15104   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15105   # take no chances and rewrite it.
15106   # Note: m4 eats our [], so we need to use [ and ] instead.
15107   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15108   if test "x$has_forbidden_chars" != x; then
15109     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15110     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15111   fi
15112 
15113     # Output is in $new_path
15114 
15115   windows_path="$new_path"
15116   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15117     unix_path=`$CYGPATH -u "$windows_path"`
15118     new_path="$unix_path"
15119   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15120     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15121     new_path="$unix_path"
15122   fi
15123 
15124     # remove trailing .exe if any
15125     new_path="${new_path/%.exe/}"
15126 
15127     # Save the first 10 bytes of this path to the storage, so fixpath can work.
15128     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15129   fi
15130 
15131   else
15132     # We're on a posix platform. Hooray! :)
15133     # First separate the path from the arguments. This will split at the first
15134     # space.
15135     complete="$FOUND_MAKE"
15136     path="${complete%% *}"
15137     tmp="$complete EOL"
15138     arguments="${tmp#* }"
15139 
15140     # Cannot rely on the command "which" here since it doesn't always work.
15141     is_absolute_path=`$ECHO "$path" | $GREP ^/`
15142     if test -z "$is_absolute_path"; then
15143       # Path to executable is not absolute. Find it.
15144       IFS_save="$IFS"
15145       IFS=:
15146       for p in $PATH; do
15147         if test -f "$p/$path" && test -x "$p/$path"; then
15148           new_path="$p/$path"
15149           break
15150         fi
15151       done
15152       IFS="$IFS_save"
15153     else
15154       { $as_echo "$as_me:${as_lineno-$LINENO}: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&5
15155 $as_echo "$as_me: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&6;}
15156       new_path="$path"
15157     fi
15158 
15159     if test "x$new_path" = x; then
15160       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15161 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15162       has_space=`$ECHO "$complete" | $GREP " "`
15163       if test "x$has_space" != x; then
15164         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
15165 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
15166       fi
15167       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15168     fi
15169   fi
15170 
15171   # Now join together the path and the arguments once again
15172   if test "x$arguments" != xEOL; then
15173     new_complete="$new_path ${arguments% *}"
15174   else
15175     new_complete="$new_path"
15176   fi
15177 
15178   if test "x$complete" != "x$new_complete"; then
15179     FOUND_MAKE="$new_complete"
15180     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
15181 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
15182   fi
15183 
15184         fi
15185       fi
15186     fi
15187   fi
15188 
15189     if test "x$FOUND_MAKE" = x; then
15190       as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make 3.81 or newer." "$LINENO" 5
15191     fi
15192   else
15193     # Try our hardest to locate a correct version of GNU make
15194     for ac_prog in gmake
15195 do
15196   # Extract the first word of "$ac_prog", so it can be a program name with args.
15197 set dummy $ac_prog; ac_word=$2
15198 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15199 $as_echo_n "checking for $ac_word... " >&6; }
15200 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
15201   $as_echo_n "(cached) " >&6
15202 else
15203   case $CHECK_GMAKE in
15204   [\\/]* | ?:[\\/]*)
15205   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
15206   ;;
15207   *)
15208   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15209 for as_dir in $PATH
15210 do
15211   IFS=$as_save_IFS
15212   test -z "$as_dir" && as_dir=.
15213     for ac_exec_ext in '' $ac_executable_extensions; do
15214   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15215     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
15216     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15217     break 2
15218   fi
15219 done
15220   done
15221 IFS=$as_save_IFS
15222 
15223   ;;
15224 esac
15225 fi
15226 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
15227 if test -n "$CHECK_GMAKE"; then
15228   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
15229 $as_echo "$CHECK_GMAKE" >&6; }
15230 else
15231   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15232 $as_echo "no" >&6; }
15233 fi
15234 
15235 
15236   test -n "$CHECK_GMAKE" && break
15237 done
15238 
15239 
15240   MAKE_CANDIDATE=""$CHECK_GMAKE""
15241   DESCRIPTION="gmake in PATH"
15242   if test "x$MAKE_CANDIDATE" != x; then
15243     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15244 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15245     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15246     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15247     if test "x$IS_GNU_MAKE" = x; then
15248       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15249 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15250     else
15251       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15252       if test "x$IS_MODERN_MAKE" = x; then
15253         { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
15254 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
15255       else
15256         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15257           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15258             MAKE_EXPECTED_ENV='cygwin'
15259           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15260             MAKE_EXPECTED_ENV='msys'
15261           else
15262             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15263           fi
15264           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15265           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15266         else
15267           # Not relevant for non-Windows
15268           IS_MAKE_CORRECT_ENV=true
15269         fi
15270         if test "x$IS_MAKE_CORRECT_ENV" = x; then
15271           { $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
15272 $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;}
15273         else
15274           FOUND_MAKE=$MAKE_CANDIDATE
15275 
15276   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15277 
15278   # First separate the path from the arguments. This will split at the first
15279   # space.
15280   complete="$FOUND_MAKE"
15281   path="${complete%% *}"
15282   tmp="$complete EOL"
15283   arguments="${tmp#* }"
15284 
15285   # Input might be given as Windows format, start by converting to
15286   # unix format.
15287   new_path=`$CYGPATH -u "$path"`
15288 
15289   # Now try to locate executable using which
15290   new_path=`$WHICH "$new_path" 2> /dev/null`
15291   # bat and cmd files are not always considered executable in cygwin causing which
15292   # to not find them
15293   if test "x$new_path" = x \
15294       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15295       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15296     new_path=`$CYGPATH -u "$path"`
15297   fi
15298   if test "x$new_path" = x; then
15299     # Oops. Which didn't find the executable.
15300     # The splitting of arguments from the executable at a space might have been incorrect,
15301     # since paths with space are more likely in Windows. Give it another try with the whole
15302     # argument.
15303     path="$complete"
15304     arguments="EOL"
15305     new_path=`$CYGPATH -u "$path"`
15306     new_path=`$WHICH "$new_path" 2> /dev/null`
15307     # bat and cmd files are not always considered executable in cygwin causing which
15308     # to not find them
15309     if test "x$new_path" = x \
15310         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15311         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15312       new_path=`$CYGPATH -u "$path"`
15313     fi
15314     if test "x$new_path" = x; then
15315       # It's still not found. Now this is an unrecoverable error.
15316       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15317 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15318       has_space=`$ECHO "$complete" | $GREP " "`
15319       if test "x$has_space" != x; then
15320         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15321 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15322       fi
15323       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15324     fi
15325   fi
15326 
15327   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15328   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15329   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15330   # "foo.exe" is OK but "foo" is an error.
15331   #
15332   # This test is therefore slightly more accurate than "test -f" to check for file presence.
15333   # It is also a way to make sure we got the proper file name for the real test later on.
15334   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15335   if test "x$test_shortpath" = x; then
15336     # Short path failed, file does not exist as specified.
15337     # Try adding .exe or .cmd
15338     if test -f "${new_path}.exe"; then
15339       input_to_shortpath="${new_path}.exe"
15340     elif test -f "${new_path}.cmd"; then
15341       input_to_shortpath="${new_path}.cmd"
15342     else
15343       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15344 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15345       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15346 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15347       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15348     fi
15349   else
15350     input_to_shortpath="$new_path"
15351   fi
15352 
15353   # Call helper function which possibly converts this using DOS-style short mode.
15354   # If so, the updated path is stored in $new_path.
15355   new_path="$input_to_shortpath"
15356 
15357   input_path="$input_to_shortpath"
15358   # Check if we need to convert this using DOS-style short mode. If the path
15359   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15360   # take no chances and rewrite it.
15361   # Note: m4 eats our [], so we need to use [ and ] instead.
15362   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15363   if test "x$has_forbidden_chars" != x; then
15364     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15365     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15366     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15367     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15368       # Going to short mode and back again did indeed matter. Since short mode is
15369       # case insensitive, let's make it lowercase to improve readability.
15370       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15371       # Now convert it back to Unix-stile (cygpath)
15372       input_path=`$CYGPATH -u "$shortmode_path"`
15373       new_path="$input_path"
15374     fi
15375   fi
15376 
15377   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15378   if test "x$test_cygdrive_prefix" = x; then
15379     # As a simple fix, exclude /usr/bin since it's not a real path.
15380     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15381       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15382       # a path prefixed by /cygdrive for fixpath to work.
15383       new_path="$CYGWIN_ROOT_PATH$input_path"
15384     fi
15385   fi
15386 
15387   # remove trailing .exe if any
15388   new_path="${new_path/%.exe/}"
15389 
15390   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15391 
15392   # First separate the path from the arguments. This will split at the first
15393   # space.
15394   complete="$FOUND_MAKE"
15395   path="${complete%% *}"
15396   tmp="$complete EOL"
15397   arguments="${tmp#* }"
15398 
15399   # Input might be given as Windows format, start by converting to
15400   # unix format.
15401   new_path="$path"
15402 
15403   windows_path="$new_path"
15404   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15405     unix_path=`$CYGPATH -u "$windows_path"`
15406     new_path="$unix_path"
15407   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15408     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15409     new_path="$unix_path"
15410   fi
15411 
15412 
15413   # Now try to locate executable using which
15414   new_path=`$WHICH "$new_path" 2> /dev/null`
15415 
15416   if test "x$new_path" = x; then
15417     # Oops. Which didn't find the executable.
15418     # The splitting of arguments from the executable at a space might have been incorrect,
15419     # since paths with space are more likely in Windows. Give it another try with the whole
15420     # argument.
15421     path="$complete"
15422     arguments="EOL"
15423     new_path="$path"
15424 
15425   windows_path="$new_path"
15426   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15427     unix_path=`$CYGPATH -u "$windows_path"`
15428     new_path="$unix_path"
15429   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15430     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15431     new_path="$unix_path"
15432   fi
15433 
15434 
15435     new_path=`$WHICH "$new_path" 2> /dev/null`
15436 
15437     if test "x$new_path" = x; then
15438       # It's still not found. Now this is an unrecoverable error.
15439       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15440 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15441       has_space=`$ECHO "$complete" | $GREP " "`
15442       if test "x$has_space" != x; then
15443         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15444 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15445       fi
15446       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15447     fi
15448   fi
15449 
15450   # Now new_path has a complete unix path to the binary
15451   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15452     # Keep paths in /bin as-is, but remove trailing .exe if any
15453     new_path="${new_path/%.exe/}"
15454     # Do not save /bin paths to all_fixpath_prefixes!
15455   else
15456     # Not in mixed or Windows style, start by that.
15457     new_path=`cmd //c echo $new_path`
15458 
15459   input_path="$new_path"
15460   # Check if we need to convert this using DOS-style short mode. If the path
15461   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15462   # take no chances and rewrite it.
15463   # Note: m4 eats our [], so we need to use [ and ] instead.
15464   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15465   if test "x$has_forbidden_chars" != x; then
15466     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15467     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15468   fi
15469 
15470     # Output is in $new_path
15471 
15472   windows_path="$new_path"
15473   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15474     unix_path=`$CYGPATH -u "$windows_path"`
15475     new_path="$unix_path"
15476   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15477     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15478     new_path="$unix_path"
15479   fi
15480 
15481     # remove trailing .exe if any
15482     new_path="${new_path/%.exe/}"
15483 
15484     # Save the first 10 bytes of this path to the storage, so fixpath can work.
15485     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15486   fi
15487 
15488   else
15489     # We're on a posix platform. Hooray! :)
15490     # First separate the path from the arguments. This will split at the first
15491     # space.
15492     complete="$FOUND_MAKE"
15493     path="${complete%% *}"
15494     tmp="$complete EOL"
15495     arguments="${tmp#* }"
15496 
15497     # Cannot rely on the command "which" here since it doesn't always work.
15498     is_absolute_path=`$ECHO "$path" | $GREP ^/`
15499     if test -z "$is_absolute_path"; then
15500       # Path to executable is not absolute. Find it.
15501       IFS_save="$IFS"
15502       IFS=:
15503       for p in $PATH; do
15504         if test -f "$p/$path" && test -x "$p/$path"; then
15505           new_path="$p/$path"
15506           break
15507         fi
15508       done
15509       IFS="$IFS_save"
15510     else
15511       { $as_echo "$as_me:${as_lineno-$LINENO}: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&5
15512 $as_echo "$as_me: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&6;}
15513       new_path="$path"
15514     fi
15515 
15516     if test "x$new_path" = x; then
15517       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15518 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15519       has_space=`$ECHO "$complete" | $GREP " "`
15520       if test "x$has_space" != x; then
15521         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
15522 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
15523       fi
15524       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15525     fi
15526   fi
15527 
15528   # Now join together the path and the arguments once again
15529   if test "x$arguments" != xEOL; then
15530     new_complete="$new_path ${arguments% *}"
15531   else
15532     new_complete="$new_path"
15533   fi
15534 
15535   if test "x$complete" != "x$new_complete"; then
15536     FOUND_MAKE="$new_complete"
15537     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
15538 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
15539   fi
15540 
15541         fi
15542       fi
15543     fi
15544   fi
15545 
15546 
15547     if test "x$FOUND_MAKE" = x; then
15548       for ac_prog in make
15549 do
15550   # Extract the first word of "$ac_prog", so it can be a program name with args.
15551 set dummy $ac_prog; ac_word=$2
15552 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15553 $as_echo_n "checking for $ac_word... " >&6; }
15554 if ${ac_cv_path_CHECK_MAKE+:} false; then :
15555   $as_echo_n "(cached) " >&6
15556 else
15557   case $CHECK_MAKE in
15558   [\\/]* | ?:[\\/]*)
15559   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
15560   ;;
15561   *)
15562   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15563 for as_dir in $PATH
15564 do
15565   IFS=$as_save_IFS
15566   test -z "$as_dir" && as_dir=.
15567     for ac_exec_ext in '' $ac_executable_extensions; do
15568   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15569     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
15570     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15571     break 2
15572   fi
15573 done
15574   done
15575 IFS=$as_save_IFS
15576 
15577   ;;
15578 esac
15579 fi
15580 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
15581 if test -n "$CHECK_MAKE"; then
15582   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
15583 $as_echo "$CHECK_MAKE" >&6; }
15584 else
15585   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15586 $as_echo "no" >&6; }
15587 fi
15588 
15589 
15590   test -n "$CHECK_MAKE" && break
15591 done
15592 
15593 
15594   MAKE_CANDIDATE=""$CHECK_MAKE""
15595   DESCRIPTION="make in PATH"
15596   if test "x$MAKE_CANDIDATE" != x; then
15597     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15598 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15599     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15600     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15601     if test "x$IS_GNU_MAKE" = x; then
15602       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15603 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15604     else
15605       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15606       if test "x$IS_MODERN_MAKE" = x; then
15607         { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
15608 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
15609       else
15610         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15611           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15612             MAKE_EXPECTED_ENV='cygwin'
15613           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15614             MAKE_EXPECTED_ENV='msys'
15615           else
15616             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15617           fi
15618           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15619           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15620         else
15621           # Not relevant for non-Windows
15622           IS_MAKE_CORRECT_ENV=true
15623         fi
15624         if test "x$IS_MAKE_CORRECT_ENV" = x; then
15625           { $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
15626 $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;}
15627         else
15628           FOUND_MAKE=$MAKE_CANDIDATE
15629 
15630   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15631 
15632   # First separate the path from the arguments. This will split at the first
15633   # space.
15634   complete="$FOUND_MAKE"
15635   path="${complete%% *}"
15636   tmp="$complete EOL"
15637   arguments="${tmp#* }"
15638 
15639   # Input might be given as Windows format, start by converting to
15640   # unix format.
15641   new_path=`$CYGPATH -u "$path"`
15642 
15643   # Now try to locate executable using which
15644   new_path=`$WHICH "$new_path" 2> /dev/null`
15645   # bat and cmd files are not always considered executable in cygwin causing which
15646   # to not find them
15647   if test "x$new_path" = x \
15648       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15649       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15650     new_path=`$CYGPATH -u "$path"`
15651   fi
15652   if test "x$new_path" = x; then
15653     # Oops. Which didn't find the executable.
15654     # The splitting of arguments from the executable at a space might have been incorrect,
15655     # since paths with space are more likely in Windows. Give it another try with the whole
15656     # argument.
15657     path="$complete"
15658     arguments="EOL"
15659     new_path=`$CYGPATH -u "$path"`
15660     new_path=`$WHICH "$new_path" 2> /dev/null`
15661     # bat and cmd files are not always considered executable in cygwin causing which
15662     # to not find them
15663     if test "x$new_path" = x \
15664         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15665         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15666       new_path=`$CYGPATH -u "$path"`
15667     fi
15668     if test "x$new_path" = x; then
15669       # It's still not found. Now this is an unrecoverable error.
15670       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15671 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15672       has_space=`$ECHO "$complete" | $GREP " "`
15673       if test "x$has_space" != x; then
15674         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15675 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15676       fi
15677       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15678     fi
15679   fi
15680 
15681   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15682   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15683   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15684   # "foo.exe" is OK but "foo" is an error.
15685   #
15686   # This test is therefore slightly more accurate than "test -f" to check for file presence.
15687   # It is also a way to make sure we got the proper file name for the real test later on.
15688   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15689   if test "x$test_shortpath" = x; then
15690     # Short path failed, file does not exist as specified.
15691     # Try adding .exe or .cmd
15692     if test -f "${new_path}.exe"; then
15693       input_to_shortpath="${new_path}.exe"
15694     elif test -f "${new_path}.cmd"; then
15695       input_to_shortpath="${new_path}.cmd"
15696     else
15697       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15698 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15699       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15700 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15701       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15702     fi
15703   else
15704     input_to_shortpath="$new_path"
15705   fi
15706 
15707   # Call helper function which possibly converts this using DOS-style short mode.
15708   # If so, the updated path is stored in $new_path.
15709   new_path="$input_to_shortpath"
15710 
15711   input_path="$input_to_shortpath"
15712   # Check if we need to convert this using DOS-style short mode. If the path
15713   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15714   # take no chances and rewrite it.
15715   # Note: m4 eats our [], so we need to use [ and ] instead.
15716   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15717   if test "x$has_forbidden_chars" != x; then
15718     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15719     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15720     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15721     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15722       # Going to short mode and back again did indeed matter. Since short mode is
15723       # case insensitive, let's make it lowercase to improve readability.
15724       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15725       # Now convert it back to Unix-stile (cygpath)
15726       input_path=`$CYGPATH -u "$shortmode_path"`
15727       new_path="$input_path"
15728     fi
15729   fi
15730 
15731   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15732   if test "x$test_cygdrive_prefix" = x; then
15733     # As a simple fix, exclude /usr/bin since it's not a real path.
15734     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15735       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15736       # a path prefixed by /cygdrive for fixpath to work.
15737       new_path="$CYGWIN_ROOT_PATH$input_path"
15738     fi
15739   fi
15740 
15741   # remove trailing .exe if any
15742   new_path="${new_path/%.exe/}"
15743 
15744   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15745 
15746   # First separate the path from the arguments. This will split at the first
15747   # space.
15748   complete="$FOUND_MAKE"
15749   path="${complete%% *}"
15750   tmp="$complete EOL"
15751   arguments="${tmp#* }"
15752 
15753   # Input might be given as Windows format, start by converting to
15754   # unix format.
15755   new_path="$path"
15756 
15757   windows_path="$new_path"
15758   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15759     unix_path=`$CYGPATH -u "$windows_path"`
15760     new_path="$unix_path"
15761   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15762     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15763     new_path="$unix_path"
15764   fi
15765 
15766 
15767   # Now try to locate executable using which
15768   new_path=`$WHICH "$new_path" 2> /dev/null`
15769 
15770   if test "x$new_path" = x; then
15771     # Oops. Which didn't find the executable.
15772     # The splitting of arguments from the executable at a space might have been incorrect,
15773     # since paths with space are more likely in Windows. Give it another try with the whole
15774     # argument.
15775     path="$complete"
15776     arguments="EOL"
15777     new_path="$path"
15778 
15779   windows_path="$new_path"
15780   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15781     unix_path=`$CYGPATH -u "$windows_path"`
15782     new_path="$unix_path"
15783   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15784     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15785     new_path="$unix_path"
15786   fi
15787 
15788 
15789     new_path=`$WHICH "$new_path" 2> /dev/null`
15790 
15791     if test "x$new_path" = x; then
15792       # It's still not found. Now this is an unrecoverable error.
15793       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15794 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15795       has_space=`$ECHO "$complete" | $GREP " "`
15796       if test "x$has_space" != x; then
15797         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15798 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15799       fi
15800       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15801     fi
15802   fi
15803 
15804   # Now new_path has a complete unix path to the binary
15805   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15806     # Keep paths in /bin as-is, but remove trailing .exe if any
15807     new_path="${new_path/%.exe/}"
15808     # Do not save /bin paths to all_fixpath_prefixes!
15809   else
15810     # Not in mixed or Windows style, start by that.
15811     new_path=`cmd //c echo $new_path`
15812 
15813   input_path="$new_path"
15814   # Check if we need to convert this using DOS-style short mode. If the path
15815   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15816   # take no chances and rewrite it.
15817   # Note: m4 eats our [], so we need to use [ and ] instead.
15818   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15819   if test "x$has_forbidden_chars" != x; then
15820     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15821     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15822   fi
15823 
15824     # Output is in $new_path
15825 
15826   windows_path="$new_path"
15827   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15828     unix_path=`$CYGPATH -u "$windows_path"`
15829     new_path="$unix_path"
15830   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15831     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15832     new_path="$unix_path"
15833   fi
15834 
15835     # remove trailing .exe if any
15836     new_path="${new_path/%.exe/}"
15837 
15838     # Save the first 10 bytes of this path to the storage, so fixpath can work.
15839     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15840   fi
15841 
15842   else
15843     # We're on a posix platform. Hooray! :)
15844     # First separate the path from the arguments. This will split at the first
15845     # space.
15846     complete="$FOUND_MAKE"
15847     path="${complete%% *}"
15848     tmp="$complete EOL"
15849     arguments="${tmp#* }"
15850 
15851     # Cannot rely on the command "which" here since it doesn't always work.
15852     is_absolute_path=`$ECHO "$path" | $GREP ^/`
15853     if test -z "$is_absolute_path"; then
15854       # Path to executable is not absolute. Find it.
15855       IFS_save="$IFS"
15856       IFS=:
15857       for p in $PATH; do
15858         if test -f "$p/$path" && test -x "$p/$path"; then
15859           new_path="$p/$path"
15860           break
15861         fi
15862       done
15863       IFS="$IFS_save"
15864     else
15865       { $as_echo "$as_me:${as_lineno-$LINENO}: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&5
15866 $as_echo "$as_me: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&6;}
15867       new_path="$path"
15868     fi
15869 
15870     if test "x$new_path" = x; then
15871       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15872 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15873       has_space=`$ECHO "$complete" | $GREP " "`
15874       if test "x$has_space" != x; then
15875         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
15876 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
15877       fi
15878       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15879     fi
15880   fi
15881 
15882   # Now join together the path and the arguments once again
15883   if test "x$arguments" != xEOL; then
15884     new_complete="$new_path ${arguments% *}"
15885   else
15886     new_complete="$new_path"
15887   fi
15888 
15889   if test "x$complete" != "x$new_complete"; then
15890     FOUND_MAKE="$new_complete"
15891     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
15892 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
15893   fi
15894 
15895         fi
15896       fi
15897     fi
15898   fi
15899 
15900     fi
15901 
15902     if test "x$FOUND_MAKE" = x; then
15903       if test "x$TOOLS_DIR" != x; then
15904         # We have a tools-dir, check that as well before giving up.
15905         OLD_PATH=$PATH
15906         PATH=$TOOLS_DIR:$PATH
15907         for ac_prog in gmake
15908 do
15909   # Extract the first word of "$ac_prog", so it can be a program name with args.
15910 set dummy $ac_prog; ac_word=$2
15911 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15912 $as_echo_n "checking for $ac_word... " >&6; }
15913 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
15914   $as_echo_n "(cached) " >&6
15915 else
15916   case $CHECK_TOOLSDIR_GMAKE in
15917   [\\/]* | ?:[\\/]*)
15918   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
15919   ;;
15920   *)
15921   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15922 for as_dir in $PATH
15923 do
15924   IFS=$as_save_IFS
15925   test -z "$as_dir" && as_dir=.
15926     for ac_exec_ext in '' $ac_executable_extensions; do
15927   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15928     ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
15929     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15930     break 2
15931   fi
15932 done
15933   done
15934 IFS=$as_save_IFS
15935 
15936   ;;
15937 esac
15938 fi
15939 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
15940 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
15941   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
15942 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
15943 else
15944   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15945 $as_echo "no" >&6; }
15946 fi
15947 
15948 
15949   test -n "$CHECK_TOOLSDIR_GMAKE" && break
15950 done
15951 
15952 
15953   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
15954   DESCRIPTION="gmake in tools-dir"
15955   if test "x$MAKE_CANDIDATE" != x; then
15956     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15957 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15958     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15959     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15960     if test "x$IS_GNU_MAKE" = x; then
15961       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15962 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15963     else
15964       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15965       if test "x$IS_MODERN_MAKE" = x; then
15966         { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
15967 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
15968       else
15969         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15970           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15971             MAKE_EXPECTED_ENV='cygwin'
15972           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15973             MAKE_EXPECTED_ENV='msys'
15974           else
15975             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15976           fi
15977           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15978           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15979         else
15980           # Not relevant for non-Windows
15981           IS_MAKE_CORRECT_ENV=true
15982         fi
15983         if test "x$IS_MAKE_CORRECT_ENV" = x; then
15984           { $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
15985 $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;}
15986         else
15987           FOUND_MAKE=$MAKE_CANDIDATE
15988 
15989   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15990 
15991   # First separate the path from the arguments. This will split at the first
15992   # space.
15993   complete="$FOUND_MAKE"
15994   path="${complete%% *}"
15995   tmp="$complete EOL"
15996   arguments="${tmp#* }"
15997 
15998   # Input might be given as Windows format, start by converting to
15999   # unix format.
16000   new_path=`$CYGPATH -u "$path"`
16001 
16002   # Now try to locate executable using which
16003   new_path=`$WHICH "$new_path" 2> /dev/null`
16004   # bat and cmd files are not always considered executable in cygwin causing which
16005   # to not find them
16006   if test "x$new_path" = x \
16007       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16008       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16009     new_path=`$CYGPATH -u "$path"`
16010   fi
16011   if test "x$new_path" = x; then
16012     # Oops. Which didn't find the executable.
16013     # The splitting of arguments from the executable at a space might have been incorrect,
16014     # since paths with space are more likely in Windows. Give it another try with the whole
16015     # argument.
16016     path="$complete"
16017     arguments="EOL"
16018     new_path=`$CYGPATH -u "$path"`
16019     new_path=`$WHICH "$new_path" 2> /dev/null`
16020     # bat and cmd files are not always considered executable in cygwin causing which
16021     # to not find them
16022     if test "x$new_path" = x \
16023         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16024         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16025       new_path=`$CYGPATH -u "$path"`
16026     fi
16027     if test "x$new_path" = x; then
16028       # It's still not found. Now this is an unrecoverable error.
16029       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16030 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16031       has_space=`$ECHO "$complete" | $GREP " "`
16032       if test "x$has_space" != x; then
16033         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16034 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16035       fi
16036       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16037     fi
16038   fi
16039 
16040   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16041   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16042   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16043   # "foo.exe" is OK but "foo" is an error.
16044   #
16045   # This test is therefore slightly more accurate than "test -f" to check for file presence.
16046   # It is also a way to make sure we got the proper file name for the real test later on.
16047   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16048   if test "x$test_shortpath" = x; then
16049     # Short path failed, file does not exist as specified.
16050     # Try adding .exe or .cmd
16051     if test -f "${new_path}.exe"; then
16052       input_to_shortpath="${new_path}.exe"
16053     elif test -f "${new_path}.cmd"; then
16054       input_to_shortpath="${new_path}.cmd"
16055     else
16056       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16057 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16058       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16059 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16060       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16061     fi
16062   else
16063     input_to_shortpath="$new_path"
16064   fi
16065 
16066   # Call helper function which possibly converts this using DOS-style short mode.
16067   # If so, the updated path is stored in $new_path.
16068   new_path="$input_to_shortpath"
16069 
16070   input_path="$input_to_shortpath"
16071   # Check if we need to convert this using DOS-style short mode. If the path
16072   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16073   # take no chances and rewrite it.
16074   # Note: m4 eats our [], so we need to use [ and ] instead.
16075   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16076   if test "x$has_forbidden_chars" != x; then
16077     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16078     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16079     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16080     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16081       # Going to short mode and back again did indeed matter. Since short mode is
16082       # case insensitive, let's make it lowercase to improve readability.
16083       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16084       # Now convert it back to Unix-stile (cygpath)
16085       input_path=`$CYGPATH -u "$shortmode_path"`
16086       new_path="$input_path"
16087     fi
16088   fi
16089 
16090   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16091   if test "x$test_cygdrive_prefix" = x; then
16092     # As a simple fix, exclude /usr/bin since it's not a real path.
16093     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16094       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16095       # a path prefixed by /cygdrive for fixpath to work.
16096       new_path="$CYGWIN_ROOT_PATH$input_path"
16097     fi
16098   fi
16099 
16100   # remove trailing .exe if any
16101   new_path="${new_path/%.exe/}"
16102 
16103   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16104 
16105   # First separate the path from the arguments. This will split at the first
16106   # space.
16107   complete="$FOUND_MAKE"
16108   path="${complete%% *}"
16109   tmp="$complete EOL"
16110   arguments="${tmp#* }"
16111 
16112   # Input might be given as Windows format, start by converting to
16113   # unix format.
16114   new_path="$path"
16115 
16116   windows_path="$new_path"
16117   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16118     unix_path=`$CYGPATH -u "$windows_path"`
16119     new_path="$unix_path"
16120   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16121     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16122     new_path="$unix_path"
16123   fi
16124 
16125 
16126   # Now try to locate executable using which
16127   new_path=`$WHICH "$new_path" 2> /dev/null`
16128 
16129   if test "x$new_path" = x; then
16130     # Oops. Which didn't find the executable.
16131     # The splitting of arguments from the executable at a space might have been incorrect,
16132     # since paths with space are more likely in Windows. Give it another try with the whole
16133     # argument.
16134     path="$complete"
16135     arguments="EOL"
16136     new_path="$path"
16137 
16138   windows_path="$new_path"
16139   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16140     unix_path=`$CYGPATH -u "$windows_path"`
16141     new_path="$unix_path"
16142   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16143     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16144     new_path="$unix_path"
16145   fi
16146 
16147 
16148     new_path=`$WHICH "$new_path" 2> /dev/null`
16149 
16150     if test "x$new_path" = x; then
16151       # It's still not found. Now this is an unrecoverable error.
16152       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16153 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16154       has_space=`$ECHO "$complete" | $GREP " "`
16155       if test "x$has_space" != x; then
16156         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16157 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16158       fi
16159       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16160     fi
16161   fi
16162 
16163   # Now new_path has a complete unix path to the binary
16164   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16165     # Keep paths in /bin as-is, but remove trailing .exe if any
16166     new_path="${new_path/%.exe/}"
16167     # Do not save /bin paths to all_fixpath_prefixes!
16168   else
16169     # Not in mixed or Windows style, start by that.
16170     new_path=`cmd //c echo $new_path`
16171 
16172   input_path="$new_path"
16173   # Check if we need to convert this using DOS-style short mode. If the path
16174   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16175   # take no chances and rewrite it.
16176   # Note: m4 eats our [], so we need to use [ and ] instead.
16177   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16178   if test "x$has_forbidden_chars" != x; then
16179     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16180     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16181   fi
16182 
16183     # Output is in $new_path
16184 
16185   windows_path="$new_path"
16186   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16187     unix_path=`$CYGPATH -u "$windows_path"`
16188     new_path="$unix_path"
16189   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16190     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16191     new_path="$unix_path"
16192   fi
16193 
16194     # remove trailing .exe if any
16195     new_path="${new_path/%.exe/}"
16196 
16197     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16198     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16199   fi
16200 
16201   else
16202     # We're on a posix platform. Hooray! :)
16203     # First separate the path from the arguments. This will split at the first
16204     # space.
16205     complete="$FOUND_MAKE"
16206     path="${complete%% *}"
16207     tmp="$complete EOL"
16208     arguments="${tmp#* }"
16209 
16210     # Cannot rely on the command "which" here since it doesn't always work.
16211     is_absolute_path=`$ECHO "$path" | $GREP ^/`
16212     if test -z "$is_absolute_path"; then
16213       # Path to executable is not absolute. Find it.
16214       IFS_save="$IFS"
16215       IFS=:
16216       for p in $PATH; do
16217         if test -f "$p/$path" && test -x "$p/$path"; then
16218           new_path="$p/$path"
16219           break
16220         fi
16221       done
16222       IFS="$IFS_save"
16223     else
16224       { $as_echo "$as_me:${as_lineno-$LINENO}: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&5
16225 $as_echo "$as_me: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&6;}
16226       new_path="$path"
16227     fi
16228 
16229     if test "x$new_path" = x; then
16230       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16231 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16232       has_space=`$ECHO "$complete" | $GREP " "`
16233       if test "x$has_space" != x; then
16234         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16235 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16236       fi
16237       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16238     fi
16239   fi
16240 
16241   # Now join together the path and the arguments once again
16242   if test "x$arguments" != xEOL; then
16243     new_complete="$new_path ${arguments% *}"
16244   else
16245     new_complete="$new_path"
16246   fi
16247 
16248   if test "x$complete" != "x$new_complete"; then
16249     FOUND_MAKE="$new_complete"
16250     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16251 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16252   fi
16253 
16254         fi
16255       fi
16256     fi
16257   fi
16258 
16259         if test "x$FOUND_MAKE" = x; then
16260           for ac_prog in make
16261 do
16262   # Extract the first word of "$ac_prog", so it can be a program name with args.
16263 set dummy $ac_prog; ac_word=$2
16264 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16265 $as_echo_n "checking for $ac_word... " >&6; }
16266 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
16267   $as_echo_n "(cached) " >&6
16268 else
16269   case $CHECK_TOOLSDIR_MAKE in
16270   [\\/]* | ?:[\\/]*)
16271   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
16272   ;;
16273   *)
16274   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16275 for as_dir in $PATH
16276 do
16277   IFS=$as_save_IFS
16278   test -z "$as_dir" && as_dir=.
16279     for ac_exec_ext in '' $ac_executable_extensions; do
16280   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16281     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
16282     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16283     break 2
16284   fi
16285 done
16286   done
16287 IFS=$as_save_IFS
16288 
16289   ;;
16290 esac
16291 fi
16292 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
16293 if test -n "$CHECK_TOOLSDIR_MAKE"; then
16294   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
16295 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
16296 else
16297   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16298 $as_echo "no" >&6; }
16299 fi
16300 
16301 
16302   test -n "$CHECK_TOOLSDIR_MAKE" && break
16303 done
16304 
16305 
16306   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
16307   DESCRIPTION="make in tools-dir"
16308   if test "x$MAKE_CANDIDATE" != x; then
16309     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16310 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16311     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16312     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16313     if test "x$IS_GNU_MAKE" = x; then
16314       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16315 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16316     else
16317       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
16318       if test "x$IS_MODERN_MAKE" = x; then
16319         { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
16320 $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
16321       else
16322         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16323           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16324             MAKE_EXPECTED_ENV='cygwin'
16325           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16326             MAKE_EXPECTED_ENV='msys'
16327           else
16328             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16329           fi
16330           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16331           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16332         else
16333           # Not relevant for non-Windows
16334           IS_MAKE_CORRECT_ENV=true
16335         fi
16336         if test "x$IS_MAKE_CORRECT_ENV" = x; then
16337           { $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
16338 $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;}
16339         else
16340           FOUND_MAKE=$MAKE_CANDIDATE
16341 
16342   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16343 
16344   # First separate the path from the arguments. This will split at the first
16345   # space.
16346   complete="$FOUND_MAKE"
16347   path="${complete%% *}"
16348   tmp="$complete EOL"
16349   arguments="${tmp#* }"
16350 
16351   # Input might be given as Windows format, start by converting to
16352   # unix format.
16353   new_path=`$CYGPATH -u "$path"`
16354 
16355   # Now try to locate executable using which
16356   new_path=`$WHICH "$new_path" 2> /dev/null`
16357   # bat and cmd files are not always considered executable in cygwin causing which
16358   # to not find them
16359   if test "x$new_path" = x \
16360       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16361       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16362     new_path=`$CYGPATH -u "$path"`
16363   fi
16364   if test "x$new_path" = x; then
16365     # Oops. Which didn't find the executable.
16366     # The splitting of arguments from the executable at a space might have been incorrect,
16367     # since paths with space are more likely in Windows. Give it another try with the whole
16368     # argument.
16369     path="$complete"
16370     arguments="EOL"
16371     new_path=`$CYGPATH -u "$path"`
16372     new_path=`$WHICH "$new_path" 2> /dev/null`
16373     # bat and cmd files are not always considered executable in cygwin causing which
16374     # to not find them
16375     if test "x$new_path" = x \
16376         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16377         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16378       new_path=`$CYGPATH -u "$path"`
16379     fi
16380     if test "x$new_path" = x; then
16381       # It's still not found. Now this is an unrecoverable error.
16382       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16383 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16384       has_space=`$ECHO "$complete" | $GREP " "`
16385       if test "x$has_space" != x; then
16386         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16387 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16388       fi
16389       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16390     fi
16391   fi
16392 
16393   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16394   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16395   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16396   # "foo.exe" is OK but "foo" is an error.
16397   #
16398   # This test is therefore slightly more accurate than "test -f" to check for file presence.
16399   # It is also a way to make sure we got the proper file name for the real test later on.
16400   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16401   if test "x$test_shortpath" = x; then
16402     # Short path failed, file does not exist as specified.
16403     # Try adding .exe or .cmd
16404     if test -f "${new_path}.exe"; then
16405       input_to_shortpath="${new_path}.exe"
16406     elif test -f "${new_path}.cmd"; then
16407       input_to_shortpath="${new_path}.cmd"
16408     else
16409       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16410 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16411       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16412 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16413       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16414     fi
16415   else
16416     input_to_shortpath="$new_path"
16417   fi
16418 
16419   # Call helper function which possibly converts this using DOS-style short mode.
16420   # If so, the updated path is stored in $new_path.
16421   new_path="$input_to_shortpath"
16422 
16423   input_path="$input_to_shortpath"
16424   # Check if we need to convert this using DOS-style short mode. If the path
16425   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16426   # take no chances and rewrite it.
16427   # Note: m4 eats our [], so we need to use [ and ] instead.
16428   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16429   if test "x$has_forbidden_chars" != x; then
16430     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16431     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16432     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16433     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16434       # Going to short mode and back again did indeed matter. Since short mode is
16435       # case insensitive, let's make it lowercase to improve readability.
16436       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16437       # Now convert it back to Unix-stile (cygpath)
16438       input_path=`$CYGPATH -u "$shortmode_path"`
16439       new_path="$input_path"
16440     fi
16441   fi
16442 
16443   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16444   if test "x$test_cygdrive_prefix" = x; then
16445     # As a simple fix, exclude /usr/bin since it's not a real path.
16446     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16447       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16448       # a path prefixed by /cygdrive for fixpath to work.
16449       new_path="$CYGWIN_ROOT_PATH$input_path"
16450     fi
16451   fi
16452 
16453   # remove trailing .exe if any
16454   new_path="${new_path/%.exe/}"
16455 
16456   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16457 
16458   # First separate the path from the arguments. This will split at the first
16459   # space.
16460   complete="$FOUND_MAKE"
16461   path="${complete%% *}"
16462   tmp="$complete EOL"
16463   arguments="${tmp#* }"
16464 
16465   # Input might be given as Windows format, start by converting to
16466   # unix format.
16467   new_path="$path"
16468 
16469   windows_path="$new_path"
16470   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16471     unix_path=`$CYGPATH -u "$windows_path"`
16472     new_path="$unix_path"
16473   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16474     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16475     new_path="$unix_path"
16476   fi
16477 
16478 
16479   # Now try to locate executable using which
16480   new_path=`$WHICH "$new_path" 2> /dev/null`
16481 
16482   if test "x$new_path" = x; then
16483     # Oops. Which didn't find the executable.
16484     # The splitting of arguments from the executable at a space might have been incorrect,
16485     # since paths with space are more likely in Windows. Give it another try with the whole
16486     # argument.
16487     path="$complete"
16488     arguments="EOL"
16489     new_path="$path"
16490 
16491   windows_path="$new_path"
16492   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16493     unix_path=`$CYGPATH -u "$windows_path"`
16494     new_path="$unix_path"
16495   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16496     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16497     new_path="$unix_path"
16498   fi
16499 
16500 
16501     new_path=`$WHICH "$new_path" 2> /dev/null`
16502 
16503     if test "x$new_path" = x; then
16504       # It's still not found. Now this is an unrecoverable error.
16505       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16506 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16507       has_space=`$ECHO "$complete" | $GREP " "`
16508       if test "x$has_space" != x; then
16509         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16510 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16511       fi
16512       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16513     fi
16514   fi
16515 
16516   # Now new_path has a complete unix path to the binary
16517   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16518     # Keep paths in /bin as-is, but remove trailing .exe if any
16519     new_path="${new_path/%.exe/}"
16520     # Do not save /bin paths to all_fixpath_prefixes!
16521   else
16522     # Not in mixed or Windows style, start by that.
16523     new_path=`cmd //c echo $new_path`
16524 
16525   input_path="$new_path"
16526   # Check if we need to convert this using DOS-style short mode. If the path
16527   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16528   # take no chances and rewrite it.
16529   # Note: m4 eats our [], so we need to use [ and ] instead.
16530   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16531   if test "x$has_forbidden_chars" != x; then
16532     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16533     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16534   fi
16535 
16536     # Output is in $new_path
16537 
16538   windows_path="$new_path"
16539   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16540     unix_path=`$CYGPATH -u "$windows_path"`
16541     new_path="$unix_path"
16542   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16543     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16544     new_path="$unix_path"
16545   fi
16546 
16547     # remove trailing .exe if any
16548     new_path="${new_path/%.exe/}"
16549 
16550     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16551     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16552   fi
16553 
16554   else
16555     # We're on a posix platform. Hooray! :)
16556     # First separate the path from the arguments. This will split at the first
16557     # space.
16558     complete="$FOUND_MAKE"
16559     path="${complete%% *}"
16560     tmp="$complete EOL"
16561     arguments="${tmp#* }"
16562 
16563     # Cannot rely on the command "which" here since it doesn't always work.
16564     is_absolute_path=`$ECHO "$path" | $GREP ^/`
16565     if test -z "$is_absolute_path"; then
16566       # Path to executable is not absolute. Find it.
16567       IFS_save="$IFS"
16568       IFS=:
16569       for p in $PATH; do
16570         if test -f "$p/$path" && test -x "$p/$path"; then
16571           new_path="$p/$path"
16572           break
16573         fi
16574       done
16575       IFS="$IFS_save"
16576     else
16577       { $as_echo "$as_me:${as_lineno-$LINENO}: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&5
16578 $as_echo "$as_me: Resolving FOUND_MAKE (as $path) failed, using $path directly." >&6;}
16579       new_path="$path"
16580     fi
16581 
16582     if test "x$new_path" = x; then
16583       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16584 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16585       has_space=`$ECHO "$complete" | $GREP " "`
16586       if test "x$has_space" != x; then
16587         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16588 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16589       fi
16590       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16591     fi
16592   fi
16593 
16594   # Now join together the path and the arguments once again
16595   if test "x$arguments" != xEOL; then
16596     new_complete="$new_path ${arguments% *}"
16597   else
16598     new_complete="$new_path"
16599   fi
16600 
16601   if test "x$complete" != "x$new_complete"; then
16602     FOUND_MAKE="$new_complete"
16603     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16604 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16605   fi
16606 
16607         fi
16608       fi
16609     fi
16610   fi
16611 
16612         fi
16613         PATH=$OLD_PATH
16614       fi
16615     fi
16616 
16617     if test "x$FOUND_MAKE" = x; then
16618       as_fn_error $? "Cannot find GNU make 3.81 or newer! Please put it in the path, or add e.g. MAKE=/opt/gmake3.81/make as argument to configure." "$LINENO" 5
16619     fi
16620   fi
16621 
16622   MAKE=$FOUND_MAKE
16623 
16624   { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
16625 $as_echo "$as_me: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
16626 
16627 
16628 
16629   # Test if find supports -delete
16630   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
16631 $as_echo_n "checking if find supports -delete... " >&6; }
16632   FIND_DELETE="-delete"
16633 
16634   DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
16635 
16636   echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
16637 
16638   TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
16639   if test -f $DELETEDIR/TestIfFindSupportsDelete; then
16640     # No, it does not.
16641     rm $DELETEDIR/TestIfFindSupportsDelete
16642     FIND_DELETE="-exec rm \{\} \+"
16643     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16644 $as_echo "no" >&6; }
16645   else
16646     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
16647 $as_echo "yes" >&6; }
16648   fi
16649   rmdir $DELETEDIR
16650 
16651 
16652 
16653   # These tools might not be installed by default,
16654   # need hint on how to install them.
16655 
16656 
16657 
16658   # Publish this variable in the help.
16659 
16660 
16661   if test "x$UNZIP" = x; then
16662     # The variable is not set by user, try to locate tool using the code snippet
16663     for ac_prog in unzip
16664 do
16665   # Extract the first word of "$ac_prog", so it can be a program name with args.
16666 set dummy $ac_prog; ac_word=$2
16667 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16668 $as_echo_n "checking for $ac_word... " >&6; }
16669 if ${ac_cv_path_UNZIP+:} false; then :
16670   $as_echo_n "(cached) " >&6
16671 else
16672   case $UNZIP in
16673   [\\/]* | ?:[\\/]*)
16674   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
16675   ;;
16676   *)
16677   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16678 for as_dir in $PATH
16679 do
16680   IFS=$as_save_IFS
16681   test -z "$as_dir" && as_dir=.
16682     for ac_exec_ext in '' $ac_executable_extensions; do
16683   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16684     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
16685     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16686     break 2
16687   fi
16688 done
16689   done
16690 IFS=$as_save_IFS
16691 
16692   ;;
16693 esac
16694 fi
16695 UNZIP=$ac_cv_path_UNZIP
16696 if test -n "$UNZIP"; then
16697   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
16698 $as_echo "$UNZIP" >&6; }
16699 else
16700   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16701 $as_echo "no" >&6; }
16702 fi
16703 
16704 
16705   test -n "$UNZIP" && break
16706 done
16707 
16708   else
16709     # The variable is set, but is it from the command line or the environment?
16710 
16711     # Try to remove the string !UNZIP! from our list.
16712     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
16713     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
16714       # If it failed, the variable was not from the command line. Ignore it,
16715       # but warn the user (except for BASH, which is always set by the calling BASH).
16716       if test "xUNZIP" != xBASH; then
16717         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
16718 $as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
16719       fi
16720       # Try to locate tool using the code snippet
16721       for ac_prog in unzip
16722 do
16723   # Extract the first word of "$ac_prog", so it can be a program name with args.
16724 set dummy $ac_prog; ac_word=$2
16725 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16726 $as_echo_n "checking for $ac_word... " >&6; }
16727 if ${ac_cv_path_UNZIP+:} false; then :
16728   $as_echo_n "(cached) " >&6
16729 else
16730   case $UNZIP in
16731   [\\/]* | ?:[\\/]*)
16732   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
16733   ;;
16734   *)
16735   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16736 for as_dir in $PATH
16737 do
16738   IFS=$as_save_IFS
16739   test -z "$as_dir" && as_dir=.
16740     for ac_exec_ext in '' $ac_executable_extensions; do
16741   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16742     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
16743     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16744     break 2
16745   fi
16746 done
16747   done
16748 IFS=$as_save_IFS
16749 
16750   ;;
16751 esac
16752 fi
16753 UNZIP=$ac_cv_path_UNZIP
16754 if test -n "$UNZIP"; then
16755   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
16756 $as_echo "$UNZIP" >&6; }
16757 else
16758   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16759 $as_echo "no" >&6; }
16760 fi
16761 
16762 
16763   test -n "$UNZIP" && break
16764 done
16765 
16766     else
16767       # If it succeeded, then it was overridden by the user. We will use it
16768       # for the tool.
16769 
16770       # First remove it from the list of overridden variables, so we can test
16771       # for unknown variables in the end.
16772       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
16773 
16774       # Check if the provided tool contains a complete path.
16775       tool_specified="$UNZIP"
16776       tool_basename="${tool_specified##*/}"
16777       if test "x$tool_basename" = "x$tool_specified"; then
16778         # A command without a complete path is provided, search $PATH.
16779         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
16780 $as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
16781         # Extract the first word of "$tool_basename", so it can be a program name with args.
16782 set dummy $tool_basename; ac_word=$2
16783 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16784 $as_echo_n "checking for $ac_word... " >&6; }
16785 if ${ac_cv_path_UNZIP+:} false; then :
16786   $as_echo_n "(cached) " >&6
16787 else
16788   case $UNZIP in
16789   [\\/]* | ?:[\\/]*)
16790   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
16791   ;;
16792   *)
16793   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16794 for as_dir in $PATH
16795 do
16796   IFS=$as_save_IFS
16797   test -z "$as_dir" && as_dir=.
16798     for ac_exec_ext in '' $ac_executable_extensions; do
16799   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16800     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
16801     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16802     break 2
16803   fi
16804 done
16805   done
16806 IFS=$as_save_IFS
16807 
16808   ;;
16809 esac
16810 fi
16811 UNZIP=$ac_cv_path_UNZIP
16812 if test -n "$UNZIP"; then
16813   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
16814 $as_echo "$UNZIP" >&6; }
16815 else
16816   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16817 $as_echo "no" >&6; }
16818 fi
16819 
16820 
16821         if test "x$UNZIP" = x; then
16822           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
16823         fi
16824       else
16825         # Otherwise we believe it is a complete path. Use it as it is.
16826         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
16827 $as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
16828         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
16829 $as_echo_n "checking for UNZIP... " >&6; }
16830         if test ! -x "$tool_specified"; then
16831           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
16832 $as_echo "not found" >&6; }
16833           as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
16834         fi
16835         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
16836 $as_echo "$tool_specified" >&6; }
16837       fi
16838     fi
16839   fi
16840 
16841 
16842 
16843   if test "x$UNZIP" = x; then
16844     as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
16845   fi
16846 
16847 
16848 
16849 
16850 
16851   # Publish this variable in the help.
16852 
16853 
16854   if test "x$ZIP" = x; then
16855     # The variable is not set by user, try to locate tool using the code snippet
16856     for ac_prog in zip
16857 do
16858   # Extract the first word of "$ac_prog", so it can be a program name with args.
16859 set dummy $ac_prog; ac_word=$2
16860 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16861 $as_echo_n "checking for $ac_word... " >&6; }
16862 if ${ac_cv_path_ZIP+:} false; then :
16863   $as_echo_n "(cached) " >&6
16864 else
16865   case $ZIP in
16866   [\\/]* | ?:[\\/]*)
16867   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
16868   ;;
16869   *)
16870   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16871 for as_dir in $PATH
16872 do
16873   IFS=$as_save_IFS
16874   test -z "$as_dir" && as_dir=.
16875     for ac_exec_ext in '' $ac_executable_extensions; do
16876   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16877     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
16878     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16879     break 2
16880   fi
16881 done
16882   done
16883 IFS=$as_save_IFS
16884 
16885   ;;
16886 esac
16887 fi
16888 ZIP=$ac_cv_path_ZIP
16889 if test -n "$ZIP"; then
16890   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
16891 $as_echo "$ZIP" >&6; }
16892 else
16893   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16894 $as_echo "no" >&6; }
16895 fi
16896 
16897 
16898   test -n "$ZIP" && break
16899 done
16900 
16901   else
16902     # The variable is set, but is it from the command line or the environment?
16903 
16904     # Try to remove the string !ZIP! from our list.
16905     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIP!/}
16906     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
16907       # If it failed, the variable was not from the command line. Ignore it,
16908       # but warn the user (except for BASH, which is always set by the calling BASH).
16909       if test "xZIP" != xBASH; then
16910         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
16911 $as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
16912       fi
16913       # Try to locate tool using the code snippet
16914       for ac_prog in zip
16915 do
16916   # Extract the first word of "$ac_prog", so it can be a program name with args.
16917 set dummy $ac_prog; ac_word=$2
16918 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16919 $as_echo_n "checking for $ac_word... " >&6; }
16920 if ${ac_cv_path_ZIP+:} false; then :
16921   $as_echo_n "(cached) " >&6
16922 else
16923   case $ZIP in
16924   [\\/]* | ?:[\\/]*)
16925   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
16926   ;;
16927   *)
16928   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16929 for as_dir in $PATH
16930 do
16931   IFS=$as_save_IFS
16932   test -z "$as_dir" && as_dir=.
16933     for ac_exec_ext in '' $ac_executable_extensions; do
16934   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16935     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
16936     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16937     break 2
16938   fi
16939 done
16940   done
16941 IFS=$as_save_IFS
16942 
16943   ;;
16944 esac
16945 fi
16946 ZIP=$ac_cv_path_ZIP
16947 if test -n "$ZIP"; then
16948   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
16949 $as_echo "$ZIP" >&6; }
16950 else
16951   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16952 $as_echo "no" >&6; }
16953 fi
16954 
16955 
16956   test -n "$ZIP" && break
16957 done
16958 
16959     else
16960       # If it succeeded, then it was overridden by the user. We will use it
16961       # for the tool.
16962 
16963       # First remove it from the list of overridden variables, so we can test
16964       # for unknown variables in the end.
16965       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
16966 
16967       # Check if the provided tool contains a complete path.
16968       tool_specified="$ZIP"
16969       tool_basename="${tool_specified##*/}"
16970       if test "x$tool_basename" = "x$tool_specified"; then
16971         # A command without a complete path is provided, search $PATH.
16972         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
16973 $as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
16974         # Extract the first word of "$tool_basename", so it can be a program name with args.
16975 set dummy $tool_basename; ac_word=$2
16976 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16977 $as_echo_n "checking for $ac_word... " >&6; }
16978 if ${ac_cv_path_ZIP+:} false; then :
16979   $as_echo_n "(cached) " >&6
16980 else
16981   case $ZIP in
16982   [\\/]* | ?:[\\/]*)
16983   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
16984   ;;
16985   *)
16986   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16987 for as_dir in $PATH
16988 do
16989   IFS=$as_save_IFS
16990   test -z "$as_dir" && as_dir=.
16991     for ac_exec_ext in '' $ac_executable_extensions; do
16992   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16993     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
16994     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16995     break 2
16996   fi
16997 done
16998   done
16999 IFS=$as_save_IFS
17000 
17001   ;;
17002 esac
17003 fi
17004 ZIP=$ac_cv_path_ZIP
17005 if test -n "$ZIP"; then
17006   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17007 $as_echo "$ZIP" >&6; }
17008 else
17009   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17010 $as_echo "no" >&6; }
17011 fi
17012 
17013 
17014         if test "x$ZIP" = x; then
17015           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17016         fi
17017       else
17018         # Otherwise we believe it is a complete path. Use it as it is.
17019         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
17020 $as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
17021         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
17022 $as_echo_n "checking for ZIP... " >&6; }
17023         if test ! -x "$tool_specified"; then
17024           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17025 $as_echo "not found" >&6; }
17026           as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17027         fi
17028         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17029 $as_echo "$tool_specified" >&6; }
17030       fi
17031     fi
17032   fi
17033 
17034 
17035 
17036   if test "x$ZIP" = x; then
17037     as_fn_error $? "Could not find required tool for ZIP" "$LINENO" 5
17038   fi
17039 
17040 
17041 
17042   # Non-required basic tools
17043 
17044 
17045 
17046   # Publish this variable in the help.
17047 
17048 
17049   if test "x$LDD" = x; then
17050     # The variable is not set by user, try to locate tool using the code snippet
17051     for ac_prog in ldd
17052 do
17053   # Extract the first word of "$ac_prog", so it can be a program name with args.
17054 set dummy $ac_prog; ac_word=$2
17055 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17056 $as_echo_n "checking for $ac_word... " >&6; }
17057 if ${ac_cv_path_LDD+:} false; then :
17058   $as_echo_n "(cached) " >&6
17059 else
17060   case $LDD in
17061   [\\/]* | ?:[\\/]*)
17062   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17063   ;;
17064   *)
17065   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17066 for as_dir in $PATH
17067 do
17068   IFS=$as_save_IFS
17069   test -z "$as_dir" && as_dir=.
17070     for ac_exec_ext in '' $ac_executable_extensions; do
17071   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17072     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17073     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17074     break 2
17075   fi
17076 done
17077   done
17078 IFS=$as_save_IFS
17079 
17080   ;;
17081 esac
17082 fi
17083 LDD=$ac_cv_path_LDD
17084 if test -n "$LDD"; then
17085   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17086 $as_echo "$LDD" >&6; }
17087 else
17088   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17089 $as_echo "no" >&6; }
17090 fi
17091 
17092 
17093   test -n "$LDD" && break
17094 done
17095 
17096   else
17097     # The variable is set, but is it from the command line or the environment?
17098 
17099     # Try to remove the string !LDD! from our list.
17100     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
17101     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17102       # If it failed, the variable was not from the command line. Ignore it,
17103       # but warn the user (except for BASH, which is always set by the calling BASH).
17104       if test "xLDD" != xBASH; then
17105         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
17106 $as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
17107       fi
17108       # Try to locate tool using the code snippet
17109       for ac_prog in ldd
17110 do
17111   # Extract the first word of "$ac_prog", so it can be a program name with args.
17112 set dummy $ac_prog; ac_word=$2
17113 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17114 $as_echo_n "checking for $ac_word... " >&6; }
17115 if ${ac_cv_path_LDD+:} false; then :
17116   $as_echo_n "(cached) " >&6
17117 else
17118   case $LDD in
17119   [\\/]* | ?:[\\/]*)
17120   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17121   ;;
17122   *)
17123   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17124 for as_dir in $PATH
17125 do
17126   IFS=$as_save_IFS
17127   test -z "$as_dir" && as_dir=.
17128     for ac_exec_ext in '' $ac_executable_extensions; do
17129   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17130     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17131     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17132     break 2
17133   fi
17134 done
17135   done
17136 IFS=$as_save_IFS
17137 
17138   ;;
17139 esac
17140 fi
17141 LDD=$ac_cv_path_LDD
17142 if test -n "$LDD"; then
17143   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17144 $as_echo "$LDD" >&6; }
17145 else
17146   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17147 $as_echo "no" >&6; }
17148 fi
17149 
17150 
17151   test -n "$LDD" && break
17152 done
17153 
17154     else
17155       # If it succeeded, then it was overridden by the user. We will use it
17156       # for the tool.
17157 
17158       # First remove it from the list of overridden variables, so we can test
17159       # for unknown variables in the end.
17160       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17161 
17162       # Check if the provided tool contains a complete path.
17163       tool_specified="$LDD"
17164       tool_basename="${tool_specified##*/}"
17165       if test "x$tool_basename" = "x$tool_specified"; then
17166         # A command without a complete path is provided, search $PATH.
17167         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
17168 $as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
17169         # Extract the first word of "$tool_basename", so it can be a program name with args.
17170 set dummy $tool_basename; ac_word=$2
17171 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17172 $as_echo_n "checking for $ac_word... " >&6; }
17173 if ${ac_cv_path_LDD+:} false; then :
17174   $as_echo_n "(cached) " >&6
17175 else
17176   case $LDD in
17177   [\\/]* | ?:[\\/]*)
17178   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17179   ;;
17180   *)
17181   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17182 for as_dir in $PATH
17183 do
17184   IFS=$as_save_IFS
17185   test -z "$as_dir" && as_dir=.
17186     for ac_exec_ext in '' $ac_executable_extensions; do
17187   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17188     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17189     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17190     break 2
17191   fi
17192 done
17193   done
17194 IFS=$as_save_IFS
17195 
17196   ;;
17197 esac
17198 fi
17199 LDD=$ac_cv_path_LDD
17200 if test -n "$LDD"; then
17201   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17202 $as_echo "$LDD" >&6; }
17203 else
17204   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17205 $as_echo "no" >&6; }
17206 fi
17207 
17208 
17209         if test "x$LDD" = x; then
17210           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17211         fi
17212       else
17213         # Otherwise we believe it is a complete path. Use it as it is.
17214         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
17215 $as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
17216         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
17217 $as_echo_n "checking for LDD... " >&6; }
17218         if test ! -x "$tool_specified"; then
17219           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17220 $as_echo "not found" >&6; }
17221           as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
17222         fi
17223         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17224 $as_echo "$tool_specified" >&6; }
17225       fi
17226     fi
17227   fi
17228 
17229 
17230   if test "x$LDD" = "x"; then
17231     # List shared lib dependencies is used for
17232     # debug output and checking for forbidden dependencies.
17233     # We can build without it.
17234     LDD="true"
17235   fi
17236 
17237 
17238   # Publish this variable in the help.
17239 
17240 
17241   if test "x$OTOOL" = x; then
17242     # The variable is not set by user, try to locate tool using the code snippet
17243     for ac_prog in otool
17244 do
17245   # Extract the first word of "$ac_prog", so it can be a program name with args.
17246 set dummy $ac_prog; ac_word=$2
17247 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17248 $as_echo_n "checking for $ac_word... " >&6; }
17249 if ${ac_cv_path_OTOOL+:} false; then :
17250   $as_echo_n "(cached) " >&6
17251 else
17252   case $OTOOL in
17253   [\\/]* | ?:[\\/]*)
17254   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
17255   ;;
17256   *)
17257   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17258 for as_dir in $PATH
17259 do
17260   IFS=$as_save_IFS
17261   test -z "$as_dir" && as_dir=.
17262     for ac_exec_ext in '' $ac_executable_extensions; do
17263   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17264     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
17265     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17266     break 2
17267   fi
17268 done
17269   done
17270 IFS=$as_save_IFS
17271 
17272   ;;
17273 esac
17274 fi
17275 OTOOL=$ac_cv_path_OTOOL
17276 if test -n "$OTOOL"; then
17277   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
17278 $as_echo "$OTOOL" >&6; }
17279 else
17280   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17281 $as_echo "no" >&6; }
17282 fi
17283 
17284 
17285   test -n "$OTOOL" && break
17286 done
17287 
17288   else
17289     # The variable is set, but is it from the command line or the environment?
17290 
17291     # Try to remove the string !OTOOL! from our list.
17292     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OTOOL!/}
17293     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17294       # If it failed, the variable was not from the command line. Ignore it,
17295       # but warn the user (except for BASH, which is always set by the calling BASH).
17296       if test "xOTOOL" != xBASH; then
17297         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&5
17298 $as_echo "$as_me: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&2;}
17299       fi
17300       # Try to locate tool using the code snippet
17301       for ac_prog in otool
17302 do
17303   # Extract the first word of "$ac_prog", so it can be a program name with args.
17304 set dummy $ac_prog; ac_word=$2
17305 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17306 $as_echo_n "checking for $ac_word... " >&6; }
17307 if ${ac_cv_path_OTOOL+:} false; then :
17308   $as_echo_n "(cached) " >&6
17309 else
17310   case $OTOOL in
17311   [\\/]* | ?:[\\/]*)
17312   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
17313   ;;
17314   *)
17315   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17316 for as_dir in $PATH
17317 do
17318   IFS=$as_save_IFS
17319   test -z "$as_dir" && as_dir=.
17320     for ac_exec_ext in '' $ac_executable_extensions; do
17321   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17322     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
17323     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17324     break 2
17325   fi
17326 done
17327   done
17328 IFS=$as_save_IFS
17329 
17330   ;;
17331 esac
17332 fi
17333 OTOOL=$ac_cv_path_OTOOL
17334 if test -n "$OTOOL"; then
17335   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
17336 $as_echo "$OTOOL" >&6; }
17337 else
17338   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17339 $as_echo "no" >&6; }
17340 fi
17341 
17342 
17343   test -n "$OTOOL" && break
17344 done
17345 
17346     else
17347       # If it succeeded, then it was overridden by the user. We will use it
17348       # for the tool.
17349 
17350       # First remove it from the list of overridden variables, so we can test
17351       # for unknown variables in the end.
17352       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17353 
17354       # Check if the provided tool contains a complete path.
17355       tool_specified="$OTOOL"
17356       tool_basename="${tool_specified##*/}"
17357       if test "x$tool_basename" = "x$tool_specified"; then
17358         # A command without a complete path is provided, search $PATH.
17359         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OTOOL=$tool_basename" >&5
17360 $as_echo "$as_me: Will search for user supplied tool OTOOL=$tool_basename" >&6;}
17361         # Extract the first word of "$tool_basename", so it can be a program name with args.
17362 set dummy $tool_basename; ac_word=$2
17363 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17364 $as_echo_n "checking for $ac_word... " >&6; }
17365 if ${ac_cv_path_OTOOL+:} false; then :
17366   $as_echo_n "(cached) " >&6
17367 else
17368   case $OTOOL in
17369   [\\/]* | ?:[\\/]*)
17370   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
17371   ;;
17372   *)
17373   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17374 for as_dir in $PATH
17375 do
17376   IFS=$as_save_IFS
17377   test -z "$as_dir" && as_dir=.
17378     for ac_exec_ext in '' $ac_executable_extensions; do
17379   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17380     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
17381     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17382     break 2
17383   fi
17384 done
17385   done
17386 IFS=$as_save_IFS
17387 
17388   ;;
17389 esac
17390 fi
17391 OTOOL=$ac_cv_path_OTOOL
17392 if test -n "$OTOOL"; then
17393   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
17394 $as_echo "$OTOOL" >&6; }
17395 else
17396   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17397 $as_echo "no" >&6; }
17398 fi
17399 
17400 
17401         if test "x$OTOOL" = x; then
17402           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17403         fi
17404       else
17405         # Otherwise we believe it is a complete path. Use it as it is.
17406         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OTOOL=$tool_specified" >&5
17407 $as_echo "$as_me: Will use user supplied tool OTOOL=$tool_specified" >&6;}
17408         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
17409 $as_echo_n "checking for OTOOL... " >&6; }
17410         if test ! -x "$tool_specified"; then
17411           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17412 $as_echo "not found" >&6; }
17413           as_fn_error $? "User supplied tool OTOOL=$tool_specified does not exist or is not executable" "$LINENO" 5
17414         fi
17415         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17416 $as_echo "$tool_specified" >&6; }
17417       fi
17418     fi
17419   fi
17420 
17421 
17422   if test "x$OTOOL" = "x"; then
17423     OTOOL="true"
17424   fi
17425 
17426 
17427   # Publish this variable in the help.
17428 
17429 
17430   if test "x$READELF" = x; then
17431     # The variable is not set by user, try to locate tool using the code snippet
17432     for ac_prog in greadelf readelf
17433 do
17434   # Extract the first word of "$ac_prog", so it can be a program name with args.
17435 set dummy $ac_prog; ac_word=$2
17436 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17437 $as_echo_n "checking for $ac_word... " >&6; }
17438 if ${ac_cv_path_READELF+:} false; then :
17439   $as_echo_n "(cached) " >&6
17440 else
17441   case $READELF in
17442   [\\/]* | ?:[\\/]*)
17443   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
17444   ;;
17445   *)
17446   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17447 for as_dir in $PATH
17448 do
17449   IFS=$as_save_IFS
17450   test -z "$as_dir" && as_dir=.
17451     for ac_exec_ext in '' $ac_executable_extensions; do
17452   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17453     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
17454     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17455     break 2
17456   fi
17457 done
17458   done
17459 IFS=$as_save_IFS
17460 
17461   ;;
17462 esac
17463 fi
17464 READELF=$ac_cv_path_READELF
17465 if test -n "$READELF"; then
17466   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
17467 $as_echo "$READELF" >&6; }
17468 else
17469   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17470 $as_echo "no" >&6; }
17471 fi
17472 
17473 
17474   test -n "$READELF" && break
17475 done
17476 
17477   else
17478     # The variable is set, but is it from the command line or the environment?
17479 
17480     # Try to remove the string !READELF! from our list.
17481     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
17482     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17483       # If it failed, the variable was not from the command line. Ignore it,
17484       # but warn the user (except for BASH, which is always set by the calling BASH).
17485       if test "xREADELF" != xBASH; then
17486         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
17487 $as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
17488       fi
17489       # Try to locate tool using the code snippet
17490       for ac_prog in greadelf readelf
17491 do
17492   # Extract the first word of "$ac_prog", so it can be a program name with args.
17493 set dummy $ac_prog; ac_word=$2
17494 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17495 $as_echo_n "checking for $ac_word... " >&6; }
17496 if ${ac_cv_path_READELF+:} false; then :
17497   $as_echo_n "(cached) " >&6
17498 else
17499   case $READELF in
17500   [\\/]* | ?:[\\/]*)
17501   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
17502   ;;
17503   *)
17504   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17505 for as_dir in $PATH
17506 do
17507   IFS=$as_save_IFS
17508   test -z "$as_dir" && as_dir=.
17509     for ac_exec_ext in '' $ac_executable_extensions; do
17510   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17511     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
17512     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17513     break 2
17514   fi
17515 done
17516   done
17517 IFS=$as_save_IFS
17518 
17519   ;;
17520 esac
17521 fi
17522 READELF=$ac_cv_path_READELF
17523 if test -n "$READELF"; then
17524   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
17525 $as_echo "$READELF" >&6; }
17526 else
17527   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17528 $as_echo "no" >&6; }
17529 fi
17530 
17531 
17532   test -n "$READELF" && break
17533 done
17534 
17535     else
17536       # If it succeeded, then it was overridden by the user. We will use it
17537       # for the tool.
17538 
17539       # First remove it from the list of overridden variables, so we can test
17540       # for unknown variables in the end.
17541       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17542 
17543       # Check if the provided tool contains a complete path.
17544       tool_specified="$READELF"
17545       tool_basename="${tool_specified##*/}"
17546       if test "x$tool_basename" = "x$tool_specified"; then
17547         # A command without a complete path is provided, search $PATH.
17548         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
17549 $as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
17550         # Extract the first word of "$tool_basename", so it can be a program name with args.
17551 set dummy $tool_basename; ac_word=$2
17552 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17553 $as_echo_n "checking for $ac_word... " >&6; }
17554 if ${ac_cv_path_READELF+:} false; then :
17555   $as_echo_n "(cached) " >&6
17556 else
17557   case $READELF in
17558   [\\/]* | ?:[\\/]*)
17559   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
17560   ;;
17561   *)
17562   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17563 for as_dir in $PATH
17564 do
17565   IFS=$as_save_IFS
17566   test -z "$as_dir" && as_dir=.
17567     for ac_exec_ext in '' $ac_executable_extensions; do
17568   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17569     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
17570     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17571     break 2
17572   fi
17573 done
17574   done
17575 IFS=$as_save_IFS
17576 
17577   ;;
17578 esac
17579 fi
17580 READELF=$ac_cv_path_READELF
17581 if test -n "$READELF"; then
17582   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
17583 $as_echo "$READELF" >&6; }
17584 else
17585   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17586 $as_echo "no" >&6; }
17587 fi
17588 
17589 
17590         if test "x$READELF" = x; then
17591           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17592         fi
17593       else
17594         # Otherwise we believe it is a complete path. Use it as it is.
17595         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
17596 $as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
17597         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
17598 $as_echo_n "checking for READELF... " >&6; }
17599         if test ! -x "$tool_specified"; then
17600           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17601 $as_echo "not found" >&6; }
17602           as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
17603         fi
17604         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17605 $as_echo "$tool_specified" >&6; }
17606       fi
17607     fi
17608   fi
17609 
17610 
17611 
17612 
17613   # Publish this variable in the help.
17614 
17615 
17616   if test "x$HG" = x; then
17617     # The variable is not set by user, try to locate tool using the code snippet
17618     for ac_prog in hg
17619 do
17620   # Extract the first word of "$ac_prog", so it can be a program name with args.
17621 set dummy $ac_prog; ac_word=$2
17622 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17623 $as_echo_n "checking for $ac_word... " >&6; }
17624 if ${ac_cv_path_HG+:} false; then :
17625   $as_echo_n "(cached) " >&6
17626 else
17627   case $HG in
17628   [\\/]* | ?:[\\/]*)
17629   ac_cv_path_HG="$HG" # Let the user override the test with a path.
17630   ;;
17631   *)
17632   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17633 for as_dir in $PATH
17634 do
17635   IFS=$as_save_IFS
17636   test -z "$as_dir" && as_dir=.
17637     for ac_exec_ext in '' $ac_executable_extensions; do
17638   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17639     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
17640     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17641     break 2
17642   fi
17643 done
17644   done
17645 IFS=$as_save_IFS
17646 
17647   ;;
17648 esac
17649 fi
17650 HG=$ac_cv_path_HG
17651 if test -n "$HG"; then
17652   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
17653 $as_echo "$HG" >&6; }
17654 else
17655   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17656 $as_echo "no" >&6; }
17657 fi
17658 
17659 
17660   test -n "$HG" && break
17661 done
17662 
17663   else
17664     # The variable is set, but is it from the command line or the environment?
17665 
17666     # Try to remove the string !HG! from our list.
17667     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
17668     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17669       # If it failed, the variable was not from the command line. Ignore it,
17670       # but warn the user (except for BASH, which is always set by the calling BASH).
17671       if test "xHG" != xBASH; then
17672         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
17673 $as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
17674       fi
17675       # Try to locate tool using the code snippet
17676       for ac_prog in hg
17677 do
17678   # Extract the first word of "$ac_prog", so it can be a program name with args.
17679 set dummy $ac_prog; ac_word=$2
17680 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17681 $as_echo_n "checking for $ac_word... " >&6; }
17682 if ${ac_cv_path_HG+:} false; then :
17683   $as_echo_n "(cached) " >&6
17684 else
17685   case $HG in
17686   [\\/]* | ?:[\\/]*)
17687   ac_cv_path_HG="$HG" # Let the user override the test with a path.
17688   ;;
17689   *)
17690   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17691 for as_dir in $PATH
17692 do
17693   IFS=$as_save_IFS
17694   test -z "$as_dir" && as_dir=.
17695     for ac_exec_ext in '' $ac_executable_extensions; do
17696   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17697     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
17698     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17699     break 2
17700   fi
17701 done
17702   done
17703 IFS=$as_save_IFS
17704 
17705   ;;
17706 esac
17707 fi
17708 HG=$ac_cv_path_HG
17709 if test -n "$HG"; then
17710   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
17711 $as_echo "$HG" >&6; }
17712 else
17713   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17714 $as_echo "no" >&6; }
17715 fi
17716 
17717 
17718   test -n "$HG" && break
17719 done
17720 
17721     else
17722       # If it succeeded, then it was overridden by the user. We will use it
17723       # for the tool.
17724 
17725       # First remove it from the list of overridden variables, so we can test
17726       # for unknown variables in the end.
17727       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17728 
17729       # Check if the provided tool contains a complete path.
17730       tool_specified="$HG"
17731       tool_basename="${tool_specified##*/}"
17732       if test "x$tool_basename" = "x$tool_specified"; then
17733         # A command without a complete path is provided, search $PATH.
17734         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
17735 $as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
17736         # Extract the first word of "$tool_basename", so it can be a program name with args.
17737 set dummy $tool_basename; ac_word=$2
17738 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17739 $as_echo_n "checking for $ac_word... " >&6; }
17740 if ${ac_cv_path_HG+:} false; then :
17741   $as_echo_n "(cached) " >&6
17742 else
17743   case $HG in
17744   [\\/]* | ?:[\\/]*)
17745   ac_cv_path_HG="$HG" # Let the user override the test with a path.
17746   ;;
17747   *)
17748   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17749 for as_dir in $PATH
17750 do
17751   IFS=$as_save_IFS
17752   test -z "$as_dir" && as_dir=.
17753     for ac_exec_ext in '' $ac_executable_extensions; do
17754   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17755     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
17756     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17757     break 2
17758   fi
17759 done
17760   done
17761 IFS=$as_save_IFS
17762 
17763   ;;
17764 esac
17765 fi
17766 HG=$ac_cv_path_HG
17767 if test -n "$HG"; then
17768   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
17769 $as_echo "$HG" >&6; }
17770 else
17771   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17772 $as_echo "no" >&6; }
17773 fi
17774 
17775 
17776         if test "x$HG" = x; then
17777           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17778         fi
17779       else
17780         # Otherwise we believe it is a complete path. Use it as it is.
17781         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
17782 $as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
17783         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
17784 $as_echo_n "checking for HG... " >&6; }
17785         if test ! -x "$tool_specified"; then
17786           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17787 $as_echo "not found" >&6; }
17788           as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
17789         fi
17790         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17791 $as_echo "$tool_specified" >&6; }
17792       fi
17793     fi
17794   fi
17795 
17796 
17797 
17798 
17799   # Publish this variable in the help.
17800 
17801 
17802   if test "x$STAT" = x; then
17803     # The variable is not set by user, try to locate tool using the code snippet
17804     for ac_prog in stat
17805 do
17806   # Extract the first word of "$ac_prog", so it can be a program name with args.
17807 set dummy $ac_prog; ac_word=$2
17808 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17809 $as_echo_n "checking for $ac_word... " >&6; }
17810 if ${ac_cv_path_STAT+:} false; then :
17811   $as_echo_n "(cached) " >&6
17812 else
17813   case $STAT in
17814   [\\/]* | ?:[\\/]*)
17815   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
17816   ;;
17817   *)
17818   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17819 for as_dir in $PATH
17820 do
17821   IFS=$as_save_IFS
17822   test -z "$as_dir" && as_dir=.
17823     for ac_exec_ext in '' $ac_executable_extensions; do
17824   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17825     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
17826     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17827     break 2
17828   fi
17829 done
17830   done
17831 IFS=$as_save_IFS
17832 
17833   ;;
17834 esac
17835 fi
17836 STAT=$ac_cv_path_STAT
17837 if test -n "$STAT"; then
17838   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
17839 $as_echo "$STAT" >&6; }
17840 else
17841   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17842 $as_echo "no" >&6; }
17843 fi
17844 
17845 
17846   test -n "$STAT" && break
17847 done
17848 
17849   else
17850     # The variable is set, but is it from the command line or the environment?
17851 
17852     # Try to remove the string !STAT! from our list.
17853     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
17854     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17855       # If it failed, the variable was not from the command line. Ignore it,
17856       # but warn the user (except for BASH, which is always set by the calling BASH).
17857       if test "xSTAT" != xBASH; then
17858         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
17859 $as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
17860       fi
17861       # Try to locate tool using the code snippet
17862       for ac_prog in stat
17863 do
17864   # Extract the first word of "$ac_prog", so it can be a program name with args.
17865 set dummy $ac_prog; ac_word=$2
17866 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17867 $as_echo_n "checking for $ac_word... " >&6; }
17868 if ${ac_cv_path_STAT+:} false; then :
17869   $as_echo_n "(cached) " >&6
17870 else
17871   case $STAT in
17872   [\\/]* | ?:[\\/]*)
17873   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
17874   ;;
17875   *)
17876   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17877 for as_dir in $PATH
17878 do
17879   IFS=$as_save_IFS
17880   test -z "$as_dir" && as_dir=.
17881     for ac_exec_ext in '' $ac_executable_extensions; do
17882   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17883     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
17884     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17885     break 2
17886   fi
17887 done
17888   done
17889 IFS=$as_save_IFS
17890 
17891   ;;
17892 esac
17893 fi
17894 STAT=$ac_cv_path_STAT
17895 if test -n "$STAT"; then
17896   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
17897 $as_echo "$STAT" >&6; }
17898 else
17899   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17900 $as_echo "no" >&6; }
17901 fi
17902 
17903 
17904   test -n "$STAT" && break
17905 done
17906 
17907     else
17908       # If it succeeded, then it was overridden by the user. We will use it
17909       # for the tool.
17910 
17911       # First remove it from the list of overridden variables, so we can test
17912       # for unknown variables in the end.
17913       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17914 
17915       # Check if the provided tool contains a complete path.
17916       tool_specified="$STAT"
17917       tool_basename="${tool_specified##*/}"
17918       if test "x$tool_basename" = "x$tool_specified"; then
17919         # A command without a complete path is provided, search $PATH.
17920         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
17921 $as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
17922         # Extract the first word of "$tool_basename", so it can be a program name with args.
17923 set dummy $tool_basename; ac_word=$2
17924 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17925 $as_echo_n "checking for $ac_word... " >&6; }
17926 if ${ac_cv_path_STAT+:} false; then :
17927   $as_echo_n "(cached) " >&6
17928 else
17929   case $STAT in
17930   [\\/]* | ?:[\\/]*)
17931   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
17932   ;;
17933   *)
17934   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17935 for as_dir in $PATH
17936 do
17937   IFS=$as_save_IFS
17938   test -z "$as_dir" && as_dir=.
17939     for ac_exec_ext in '' $ac_executable_extensions; do
17940   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17941     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
17942     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17943     break 2
17944   fi
17945 done
17946   done
17947 IFS=$as_save_IFS
17948 
17949   ;;
17950 esac
17951 fi
17952 STAT=$ac_cv_path_STAT
17953 if test -n "$STAT"; then
17954   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
17955 $as_echo "$STAT" >&6; }
17956 else
17957   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17958 $as_echo "no" >&6; }
17959 fi
17960 
17961 
17962         if test "x$STAT" = x; then
17963           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17964         fi
17965       else
17966         # Otherwise we believe it is a complete path. Use it as it is.
17967         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
17968 $as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
17969         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
17970 $as_echo_n "checking for STAT... " >&6; }
17971         if test ! -x "$tool_specified"; then
17972           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17973 $as_echo "not found" >&6; }
17974           as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
17975         fi
17976         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17977 $as_echo "$tool_specified" >&6; }
17978       fi
17979     fi
17980   fi
17981 
17982 
17983 
17984 
17985   # Publish this variable in the help.
17986 
17987 
17988   if test "x$TIME" = x; then
17989     # The variable is not set by user, try to locate tool using the code snippet
17990     for ac_prog in time
17991 do
17992   # Extract the first word of "$ac_prog", so it can be a program name with args.
17993 set dummy $ac_prog; ac_word=$2
17994 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17995 $as_echo_n "checking for $ac_word... " >&6; }
17996 if ${ac_cv_path_TIME+:} false; then :
17997   $as_echo_n "(cached) " >&6
17998 else
17999   case $TIME in
18000   [\\/]* | ?:[\\/]*)
18001   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18002   ;;
18003   *)
18004   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18005 for as_dir in $PATH
18006 do
18007   IFS=$as_save_IFS
18008   test -z "$as_dir" && as_dir=.
18009     for ac_exec_ext in '' $ac_executable_extensions; do
18010   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18011     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18012     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18013     break 2
18014   fi
18015 done
18016   done
18017 IFS=$as_save_IFS
18018 
18019   ;;
18020 esac
18021 fi
18022 TIME=$ac_cv_path_TIME
18023 if test -n "$TIME"; then
18024   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18025 $as_echo "$TIME" >&6; }
18026 else
18027   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18028 $as_echo "no" >&6; }
18029 fi
18030 
18031 
18032   test -n "$TIME" && break
18033 done
18034 
18035   else
18036     # The variable is set, but is it from the command line or the environment?
18037 
18038     # Try to remove the string !TIME! from our list.
18039     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
18040     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18041       # If it failed, the variable was not from the command line. Ignore it,
18042       # but warn the user (except for BASH, which is always set by the calling BASH).
18043       if test "xTIME" != xBASH; then
18044         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
18045 $as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
18046       fi
18047       # Try to locate tool using the code snippet
18048       for ac_prog in time
18049 do
18050   # Extract the first word of "$ac_prog", so it can be a program name with args.
18051 set dummy $ac_prog; ac_word=$2
18052 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18053 $as_echo_n "checking for $ac_word... " >&6; }
18054 if ${ac_cv_path_TIME+:} false; then :
18055   $as_echo_n "(cached) " >&6
18056 else
18057   case $TIME in
18058   [\\/]* | ?:[\\/]*)
18059   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18060   ;;
18061   *)
18062   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18063 for as_dir in $PATH
18064 do
18065   IFS=$as_save_IFS
18066   test -z "$as_dir" && as_dir=.
18067     for ac_exec_ext in '' $ac_executable_extensions; do
18068   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18069     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18070     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18071     break 2
18072   fi
18073 done
18074   done
18075 IFS=$as_save_IFS
18076 
18077   ;;
18078 esac
18079 fi
18080 TIME=$ac_cv_path_TIME
18081 if test -n "$TIME"; then
18082   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18083 $as_echo "$TIME" >&6; }
18084 else
18085   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18086 $as_echo "no" >&6; }
18087 fi
18088 
18089 
18090   test -n "$TIME" && break
18091 done
18092 
18093     else
18094       # If it succeeded, then it was overridden by the user. We will use it
18095       # for the tool.
18096 
18097       # First remove it from the list of overridden variables, so we can test
18098       # for unknown variables in the end.
18099       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18100 
18101       # Check if the provided tool contains a complete path.
18102       tool_specified="$TIME"
18103       tool_basename="${tool_specified##*/}"
18104       if test "x$tool_basename" = "x$tool_specified"; then
18105         # A command without a complete path is provided, search $PATH.
18106         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
18107 $as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
18108         # Extract the first word of "$tool_basename", so it can be a program name with args.
18109 set dummy $tool_basename; ac_word=$2
18110 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18111 $as_echo_n "checking for $ac_word... " >&6; }
18112 if ${ac_cv_path_TIME+:} false; then :
18113   $as_echo_n "(cached) " >&6
18114 else
18115   case $TIME in
18116   [\\/]* | ?:[\\/]*)
18117   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18118   ;;
18119   *)
18120   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18121 for as_dir in $PATH
18122 do
18123   IFS=$as_save_IFS
18124   test -z "$as_dir" && as_dir=.
18125     for ac_exec_ext in '' $ac_executable_extensions; do
18126   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18127     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18128     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18129     break 2
18130   fi
18131 done
18132   done
18133 IFS=$as_save_IFS
18134 
18135   ;;
18136 esac
18137 fi
18138 TIME=$ac_cv_path_TIME
18139 if test -n "$TIME"; then
18140   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18141 $as_echo "$TIME" >&6; }
18142 else
18143   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18144 $as_echo "no" >&6; }
18145 fi
18146 
18147 
18148         if test "x$TIME" = x; then
18149           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18150         fi
18151       else
18152         # Otherwise we believe it is a complete path. Use it as it is.
18153         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
18154 $as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
18155         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
18156 $as_echo_n "checking for TIME... " >&6; }
18157         if test ! -x "$tool_specified"; then
18158           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18159 $as_echo "not found" >&6; }
18160           as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
18161         fi
18162         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18163 $as_echo "$tool_specified" >&6; }
18164       fi
18165     fi
18166   fi
18167 
18168 
18169   # Check if it's GNU time
18170   IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
18171   if test "x$IS_GNU_TIME" != x; then
18172     IS_GNU_TIME=yes
18173   else
18174     IS_GNU_TIME=no
18175   fi
18176 
18177 
18178   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
18179 
18180 
18181 
18182   # Publish this variable in the help.
18183 
18184 
18185   if test "x$COMM" = x; then
18186     # The variable is not set by user, try to locate tool using the code snippet
18187     for ac_prog in comm
18188 do
18189   # Extract the first word of "$ac_prog", so it can be a program name with args.
18190 set dummy $ac_prog; ac_word=$2
18191 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18192 $as_echo_n "checking for $ac_word... " >&6; }
18193 if ${ac_cv_path_COMM+:} false; then :
18194   $as_echo_n "(cached) " >&6
18195 else
18196   case $COMM in
18197   [\\/]* | ?:[\\/]*)
18198   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
18199   ;;
18200   *)
18201   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18202 for as_dir in $PATH
18203 do
18204   IFS=$as_save_IFS
18205   test -z "$as_dir" && as_dir=.
18206     for ac_exec_ext in '' $ac_executable_extensions; do
18207   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18208     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
18209     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18210     break 2
18211   fi
18212 done
18213   done
18214 IFS=$as_save_IFS
18215 
18216   ;;
18217 esac
18218 fi
18219 COMM=$ac_cv_path_COMM
18220 if test -n "$COMM"; then
18221   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
18222 $as_echo "$COMM" >&6; }
18223 else
18224   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18225 $as_echo "no" >&6; }
18226 fi
18227 
18228 
18229   test -n "$COMM" && break
18230 done
18231 
18232   else
18233     # The variable is set, but is it from the command line or the environment?
18234 
18235     # Try to remove the string !COMM! from our list.
18236     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
18237     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18238       # If it failed, the variable was not from the command line. Ignore it,
18239       # but warn the user (except for BASH, which is always set by the calling BASH).
18240       if test "xCOMM" != xBASH; then
18241         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
18242 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
18243       fi
18244       # Try to locate tool using the code snippet
18245       for ac_prog in comm
18246 do
18247   # Extract the first word of "$ac_prog", so it can be a program name with args.
18248 set dummy $ac_prog; ac_word=$2
18249 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18250 $as_echo_n "checking for $ac_word... " >&6; }
18251 if ${ac_cv_path_COMM+:} false; then :
18252   $as_echo_n "(cached) " >&6
18253 else
18254   case $COMM in
18255   [\\/]* | ?:[\\/]*)
18256   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
18257   ;;
18258   *)
18259   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18260 for as_dir in $PATH
18261 do
18262   IFS=$as_save_IFS
18263   test -z "$as_dir" && as_dir=.
18264     for ac_exec_ext in '' $ac_executable_extensions; do
18265   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18266     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
18267     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18268     break 2
18269   fi
18270 done
18271   done
18272 IFS=$as_save_IFS
18273 
18274   ;;
18275 esac
18276 fi
18277 COMM=$ac_cv_path_COMM
18278 if test -n "$COMM"; then
18279   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
18280 $as_echo "$COMM" >&6; }
18281 else
18282   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18283 $as_echo "no" >&6; }
18284 fi
18285 
18286 
18287   test -n "$COMM" && break
18288 done
18289 
18290     else
18291       # If it succeeded, then it was overridden by the user. We will use it
18292       # for the tool.
18293 
18294       # First remove it from the list of overridden variables, so we can test
18295       # for unknown variables in the end.
18296       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18297 
18298       # Check if the provided tool contains a complete path.
18299       tool_specified="$COMM"
18300       tool_basename="${tool_specified##*/}"
18301       if test "x$tool_basename" = "x$tool_specified"; then
18302         # A command without a complete path is provided, search $PATH.
18303         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
18304 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
18305         # Extract the first word of "$tool_basename", so it can be a program name with args.
18306 set dummy $tool_basename; ac_word=$2
18307 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18308 $as_echo_n "checking for $ac_word... " >&6; }
18309 if ${ac_cv_path_COMM+:} false; then :
18310   $as_echo_n "(cached) " >&6
18311 else
18312   case $COMM in
18313   [\\/]* | ?:[\\/]*)
18314   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
18315   ;;
18316   *)
18317   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18318 for as_dir in $PATH
18319 do
18320   IFS=$as_save_IFS
18321   test -z "$as_dir" && as_dir=.
18322     for ac_exec_ext in '' $ac_executable_extensions; do
18323   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18324     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
18325     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18326     break 2
18327   fi
18328 done
18329   done
18330 IFS=$as_save_IFS
18331 
18332   ;;
18333 esac
18334 fi
18335 COMM=$ac_cv_path_COMM
18336 if test -n "$COMM"; then
18337   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
18338 $as_echo "$COMM" >&6; }
18339 else
18340   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18341 $as_echo "no" >&6; }
18342 fi
18343 
18344 
18345         if test "x$COMM" = x; then
18346           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18347         fi
18348       else
18349         # Otherwise we believe it is a complete path. Use it as it is.
18350         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
18351 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
18352         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
18353 $as_echo_n "checking for COMM... " >&6; }
18354         if test ! -x "$tool_specified"; then
18355           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18356 $as_echo "not found" >&6; }
18357           as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
18358         fi
18359         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18360 $as_echo "$tool_specified" >&6; }
18361       fi
18362     fi
18363   fi
18364 
18365 
18366 
18367   if test "x$COMM" = x; then
18368     as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
18369   fi
18370 
18371 
18372   fi
18373 
18374   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
18375 
18376 
18377 
18378   # Publish this variable in the help.
18379 
18380 
18381   if test "x$DSYMUTIL" = x; then
18382     # The variable is not set by user, try to locate tool using the code snippet
18383     for ac_prog in dsymutil
18384 do
18385   # Extract the first word of "$ac_prog", so it can be a program name with args.
18386 set dummy $ac_prog; ac_word=$2
18387 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18388 $as_echo_n "checking for $ac_word... " >&6; }
18389 if ${ac_cv_path_DSYMUTIL+:} false; then :
18390   $as_echo_n "(cached) " >&6
18391 else
18392   case $DSYMUTIL in
18393   [\\/]* | ?:[\\/]*)
18394   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18395   ;;
18396   *)
18397   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18398 for as_dir in $PATH
18399 do
18400   IFS=$as_save_IFS
18401   test -z "$as_dir" && as_dir=.
18402     for ac_exec_ext in '' $ac_executable_extensions; do
18403   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18404     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18405     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18406     break 2
18407   fi
18408 done
18409   done
18410 IFS=$as_save_IFS
18411 
18412   ;;
18413 esac
18414 fi
18415 DSYMUTIL=$ac_cv_path_DSYMUTIL
18416 if test -n "$DSYMUTIL"; then
18417   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18418 $as_echo "$DSYMUTIL" >&6; }
18419 else
18420   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18421 $as_echo "no" >&6; }
18422 fi
18423 
18424 
18425   test -n "$DSYMUTIL" && break
18426 done
18427 
18428   else
18429     # The variable is set, but is it from the command line or the environment?
18430 
18431     # Try to remove the string !DSYMUTIL! from our list.
18432     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
18433     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18434       # If it failed, the variable was not from the command line. Ignore it,
18435       # but warn the user (except for BASH, which is always set by the calling BASH).
18436       if test "xDSYMUTIL" != xBASH; then
18437         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
18438 $as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
18439       fi
18440       # Try to locate tool using the code snippet
18441       for ac_prog in dsymutil
18442 do
18443   # Extract the first word of "$ac_prog", so it can be a program name with args.
18444 set dummy $ac_prog; ac_word=$2
18445 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18446 $as_echo_n "checking for $ac_word... " >&6; }
18447 if ${ac_cv_path_DSYMUTIL+:} false; then :
18448   $as_echo_n "(cached) " >&6
18449 else
18450   case $DSYMUTIL in
18451   [\\/]* | ?:[\\/]*)
18452   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18453   ;;
18454   *)
18455   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18456 for as_dir in $PATH
18457 do
18458   IFS=$as_save_IFS
18459   test -z "$as_dir" && as_dir=.
18460     for ac_exec_ext in '' $ac_executable_extensions; do
18461   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18462     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18463     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18464     break 2
18465   fi
18466 done
18467   done
18468 IFS=$as_save_IFS
18469 
18470   ;;
18471 esac
18472 fi
18473 DSYMUTIL=$ac_cv_path_DSYMUTIL
18474 if test -n "$DSYMUTIL"; then
18475   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18476 $as_echo "$DSYMUTIL" >&6; }
18477 else
18478   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18479 $as_echo "no" >&6; }
18480 fi
18481 
18482 
18483   test -n "$DSYMUTIL" && break
18484 done
18485 
18486     else
18487       # If it succeeded, then it was overridden by the user. We will use it
18488       # for the tool.
18489 
18490       # First remove it from the list of overridden variables, so we can test
18491       # for unknown variables in the end.
18492       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18493 
18494       # Check if the provided tool contains a complete path.
18495       tool_specified="$DSYMUTIL"
18496       tool_basename="${tool_specified##*/}"
18497       if test "x$tool_basename" = "x$tool_specified"; then
18498         # A command without a complete path is provided, search $PATH.
18499         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
18500 $as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
18501         # Extract the first word of "$tool_basename", so it can be a program name with args.
18502 set dummy $tool_basename; ac_word=$2
18503 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18504 $as_echo_n "checking for $ac_word... " >&6; }
18505 if ${ac_cv_path_DSYMUTIL+:} false; then :
18506   $as_echo_n "(cached) " >&6
18507 else
18508   case $DSYMUTIL in
18509   [\\/]* | ?:[\\/]*)
18510   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18511   ;;
18512   *)
18513   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18514 for as_dir in $PATH
18515 do
18516   IFS=$as_save_IFS
18517   test -z "$as_dir" && as_dir=.
18518     for ac_exec_ext in '' $ac_executable_extensions; do
18519   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18520     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18521     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18522     break 2
18523   fi
18524 done
18525   done
18526 IFS=$as_save_IFS
18527 
18528   ;;
18529 esac
18530 fi
18531 DSYMUTIL=$ac_cv_path_DSYMUTIL
18532 if test -n "$DSYMUTIL"; then
18533   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18534 $as_echo "$DSYMUTIL" >&6; }
18535 else
18536   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18537 $as_echo "no" >&6; }
18538 fi
18539 
18540 
18541         if test "x$DSYMUTIL" = x; then
18542           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18543         fi
18544       else
18545         # Otherwise we believe it is a complete path. Use it as it is.
18546         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
18547 $as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
18548         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
18549 $as_echo_n "checking for DSYMUTIL... " >&6; }
18550         if test ! -x "$tool_specified"; then
18551           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18552 $as_echo "not found" >&6; }
18553           as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
18554         fi
18555         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18556 $as_echo "$tool_specified" >&6; }
18557       fi
18558     fi
18559   fi
18560 
18561 
18562 
18563   if test "x$DSYMUTIL" = x; then
18564     as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
18565   fi
18566 
18567 
18568 
18569 
18570 
18571   # Publish this variable in the help.
18572 
18573 
18574   if test "x$XATTR" = x; then
18575     # The variable is not set by user, try to locate tool using the code snippet
18576     for ac_prog in xattr
18577 do
18578   # Extract the first word of "$ac_prog", so it can be a program name with args.
18579 set dummy $ac_prog; ac_word=$2
18580 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18581 $as_echo_n "checking for $ac_word... " >&6; }
18582 if ${ac_cv_path_XATTR+:} false; then :
18583   $as_echo_n "(cached) " >&6
18584 else
18585   case $XATTR in
18586   [\\/]* | ?:[\\/]*)
18587   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
18588   ;;
18589   *)
18590   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18591 for as_dir in $PATH
18592 do
18593   IFS=$as_save_IFS
18594   test -z "$as_dir" && as_dir=.
18595     for ac_exec_ext in '' $ac_executable_extensions; do
18596   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18597     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
18598     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18599     break 2
18600   fi
18601 done
18602   done
18603 IFS=$as_save_IFS
18604 
18605   ;;
18606 esac
18607 fi
18608 XATTR=$ac_cv_path_XATTR
18609 if test -n "$XATTR"; then
18610   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
18611 $as_echo "$XATTR" >&6; }
18612 else
18613   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18614 $as_echo "no" >&6; }
18615 fi
18616 
18617 
18618   test -n "$XATTR" && break
18619 done
18620 
18621   else
18622     # The variable is set, but is it from the command line or the environment?
18623 
18624     # Try to remove the string !XATTR! from our list.
18625     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
18626     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18627       # If it failed, the variable was not from the command line. Ignore it,
18628       # but warn the user (except for BASH, which is always set by the calling BASH).
18629       if test "xXATTR" != xBASH; then
18630         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
18631 $as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
18632       fi
18633       # Try to locate tool using the code snippet
18634       for ac_prog in xattr
18635 do
18636   # Extract the first word of "$ac_prog", so it can be a program name with args.
18637 set dummy $ac_prog; ac_word=$2
18638 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18639 $as_echo_n "checking for $ac_word... " >&6; }
18640 if ${ac_cv_path_XATTR+:} false; then :
18641   $as_echo_n "(cached) " >&6
18642 else
18643   case $XATTR in
18644   [\\/]* | ?:[\\/]*)
18645   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
18646   ;;
18647   *)
18648   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18649 for as_dir in $PATH
18650 do
18651   IFS=$as_save_IFS
18652   test -z "$as_dir" && as_dir=.
18653     for ac_exec_ext in '' $ac_executable_extensions; do
18654   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18655     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
18656     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18657     break 2
18658   fi
18659 done
18660   done
18661 IFS=$as_save_IFS
18662 
18663   ;;
18664 esac
18665 fi
18666 XATTR=$ac_cv_path_XATTR
18667 if test -n "$XATTR"; then
18668   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
18669 $as_echo "$XATTR" >&6; }
18670 else
18671   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18672 $as_echo "no" >&6; }
18673 fi
18674 
18675 
18676   test -n "$XATTR" && break
18677 done
18678 
18679     else
18680       # If it succeeded, then it was overridden by the user. We will use it
18681       # for the tool.
18682 
18683       # First remove it from the list of overridden variables, so we can test
18684       # for unknown variables in the end.
18685       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18686 
18687       # Check if the provided tool contains a complete path.
18688       tool_specified="$XATTR"
18689       tool_basename="${tool_specified##*/}"
18690       if test "x$tool_basename" = "x$tool_specified"; then
18691         # A command without a complete path is provided, search $PATH.
18692         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
18693 $as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
18694         # Extract the first word of "$tool_basename", so it can be a program name with args.
18695 set dummy $tool_basename; ac_word=$2
18696 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18697 $as_echo_n "checking for $ac_word... " >&6; }
18698 if ${ac_cv_path_XATTR+:} false; then :
18699   $as_echo_n "(cached) " >&6
18700 else
18701   case $XATTR in
18702   [\\/]* | ?:[\\/]*)
18703   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
18704   ;;
18705   *)
18706   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18707 for as_dir in $PATH
18708 do
18709   IFS=$as_save_IFS
18710   test -z "$as_dir" && as_dir=.
18711     for ac_exec_ext in '' $ac_executable_extensions; do
18712   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18713     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
18714     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18715     break 2
18716   fi
18717 done
18718   done
18719 IFS=$as_save_IFS
18720 
18721   ;;
18722 esac
18723 fi
18724 XATTR=$ac_cv_path_XATTR
18725 if test -n "$XATTR"; then
18726   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
18727 $as_echo "$XATTR" >&6; }
18728 else
18729   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18730 $as_echo "no" >&6; }
18731 fi
18732 
18733 
18734         if test "x$XATTR" = x; then
18735           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18736         fi
18737       else
18738         # Otherwise we believe it is a complete path. Use it as it is.
18739         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
18740 $as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
18741         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
18742 $as_echo_n "checking for XATTR... " >&6; }
18743         if test ! -x "$tool_specified"; then
18744           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18745 $as_echo "not found" >&6; }
18746           as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
18747         fi
18748         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18749 $as_echo "$tool_specified" >&6; }
18750       fi
18751     fi
18752   fi
18753 
18754 
18755 
18756   if test "x$XATTR" = x; then
18757     as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
18758   fi
18759 
18760 
18761 
18762 
18763   # Publish this variable in the help.
18764 
18765 
18766   if test "x$CODESIGN" = x; then
18767     # The variable is not set by user, try to locate tool using the code snippet
18768     for ac_prog in codesign
18769 do
18770   # Extract the first word of "$ac_prog", so it can be a program name with args.
18771 set dummy $ac_prog; ac_word=$2
18772 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18773 $as_echo_n "checking for $ac_word... " >&6; }
18774 if ${ac_cv_path_CODESIGN+:} false; then :
18775   $as_echo_n "(cached) " >&6
18776 else
18777   case $CODESIGN in
18778   [\\/]* | ?:[\\/]*)
18779   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
18780   ;;
18781   *)
18782   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18783 for as_dir in $PATH
18784 do
18785   IFS=$as_save_IFS
18786   test -z "$as_dir" && as_dir=.
18787     for ac_exec_ext in '' $ac_executable_extensions; do
18788   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18789     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
18790     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18791     break 2
18792   fi
18793 done
18794   done
18795 IFS=$as_save_IFS
18796 
18797   ;;
18798 esac
18799 fi
18800 CODESIGN=$ac_cv_path_CODESIGN
18801 if test -n "$CODESIGN"; then
18802   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
18803 $as_echo "$CODESIGN" >&6; }
18804 else
18805   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18806 $as_echo "no" >&6; }
18807 fi
18808 
18809 
18810   test -n "$CODESIGN" && break
18811 done
18812 
18813   else
18814     # The variable is set, but is it from the command line or the environment?
18815 
18816     # Try to remove the string !CODESIGN! from our list.
18817     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
18818     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18819       # If it failed, the variable was not from the command line. Ignore it,
18820       # but warn the user (except for BASH, which is always set by the calling BASH).
18821       if test "xCODESIGN" != xBASH; then
18822         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
18823 $as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
18824       fi
18825       # Try to locate tool using the code snippet
18826       for ac_prog in codesign
18827 do
18828   # Extract the first word of "$ac_prog", so it can be a program name with args.
18829 set dummy $ac_prog; ac_word=$2
18830 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18831 $as_echo_n "checking for $ac_word... " >&6; }
18832 if ${ac_cv_path_CODESIGN+:} false; then :
18833   $as_echo_n "(cached) " >&6
18834 else
18835   case $CODESIGN in
18836   [\\/]* | ?:[\\/]*)
18837   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
18838   ;;
18839   *)
18840   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18841 for as_dir in $PATH
18842 do
18843   IFS=$as_save_IFS
18844   test -z "$as_dir" && as_dir=.
18845     for ac_exec_ext in '' $ac_executable_extensions; do
18846   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18847     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
18848     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18849     break 2
18850   fi
18851 done
18852   done
18853 IFS=$as_save_IFS
18854 
18855   ;;
18856 esac
18857 fi
18858 CODESIGN=$ac_cv_path_CODESIGN
18859 if test -n "$CODESIGN"; then
18860   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
18861 $as_echo "$CODESIGN" >&6; }
18862 else
18863   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18864 $as_echo "no" >&6; }
18865 fi
18866 
18867 
18868   test -n "$CODESIGN" && break
18869 done
18870 
18871     else
18872       # If it succeeded, then it was overridden by the user. We will use it
18873       # for the tool.
18874 
18875       # First remove it from the list of overridden variables, so we can test
18876       # for unknown variables in the end.
18877       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18878 
18879       # Check if the provided tool contains a complete path.
18880       tool_specified="$CODESIGN"
18881       tool_basename="${tool_specified##*/}"
18882       if test "x$tool_basename" = "x$tool_specified"; then
18883         # A command without a complete path is provided, search $PATH.
18884         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
18885 $as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
18886         # Extract the first word of "$tool_basename", so it can be a program name with args.
18887 set dummy $tool_basename; ac_word=$2
18888 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18889 $as_echo_n "checking for $ac_word... " >&6; }
18890 if ${ac_cv_path_CODESIGN+:} false; then :
18891   $as_echo_n "(cached) " >&6
18892 else
18893   case $CODESIGN in
18894   [\\/]* | ?:[\\/]*)
18895   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
18896   ;;
18897   *)
18898   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18899 for as_dir in $PATH
18900 do
18901   IFS=$as_save_IFS
18902   test -z "$as_dir" && as_dir=.
18903     for ac_exec_ext in '' $ac_executable_extensions; do
18904   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18905     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
18906     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18907     break 2
18908   fi
18909 done
18910   done
18911 IFS=$as_save_IFS
18912 
18913   ;;
18914 esac
18915 fi
18916 CODESIGN=$ac_cv_path_CODESIGN
18917 if test -n "$CODESIGN"; then
18918   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
18919 $as_echo "$CODESIGN" >&6; }
18920 else
18921   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18922 $as_echo "no" >&6; }
18923 fi
18924 
18925 
18926         if test "x$CODESIGN" = x; then
18927           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18928         fi
18929       else
18930         # Otherwise we believe it is a complete path. Use it as it is.
18931         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
18932 $as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
18933         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
18934 $as_echo_n "checking for CODESIGN... " >&6; }
18935         if test ! -x "$tool_specified"; then
18936           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18937 $as_echo "not found" >&6; }
18938           as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
18939         fi
18940         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18941 $as_echo "$tool_specified" >&6; }
18942       fi
18943     fi
18944   fi
18945 
18946 
18947     if test "x$CODESIGN" != "x"; then
18948       # Verify that the openjdk_codesign certificate is present
18949       { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
18950 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
18951       rm -f codesign-testfile
18952       touch codesign-testfile
18953       codesign -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
18954       rm -f codesign-testfile
18955       if test "x$CODESIGN" = x; then
18956         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18957 $as_echo "no" >&6; }
18958       else
18959         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
18960 $as_echo "yes" >&6; }
18961       fi
18962     fi
18963   fi
18964 
18965 
18966 # Check if pkg-config is available.
18967 
18968 
18969 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
18970         if test -n "$ac_tool_prefix"; then
18971   # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
18972 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
18973 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18974 $as_echo_n "checking for $ac_word... " >&6; }
18975 if ${ac_cv_path_PKG_CONFIG+:} false; then :
18976   $as_echo_n "(cached) " >&6
18977 else
18978   case $PKG_CONFIG in
18979   [\\/]* | ?:[\\/]*)
18980   ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
18981   ;;
18982   *)
18983   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18984 for as_dir in $PATH
18985 do
18986   IFS=$as_save_IFS
18987   test -z "$as_dir" && as_dir=.
18988     for ac_exec_ext in '' $ac_executable_extensions; do
18989   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18990     ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
18991     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18992     break 2
18993   fi
18994 done
18995   done
18996 IFS=$as_save_IFS
18997 
18998   ;;
18999 esac
19000 fi
19001 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
19002 if test -n "$PKG_CONFIG"; then
19003   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
19004 $as_echo "$PKG_CONFIG" >&6; }
19005 else
19006   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19007 $as_echo "no" >&6; }
19008 fi
19009 
19010 
19011 fi
19012 if test -z "$ac_cv_path_PKG_CONFIG"; then
19013   ac_pt_PKG_CONFIG=$PKG_CONFIG
19014   # Extract the first word of "pkg-config", so it can be a program name with args.
19015 set dummy pkg-config; ac_word=$2
19016 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19017 $as_echo_n "checking for $ac_word... " >&6; }
19018 if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
19019   $as_echo_n "(cached) " >&6
19020 else
19021   case $ac_pt_PKG_CONFIG in
19022   [\\/]* | ?:[\\/]*)
19023   ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
19024   ;;
19025   *)
19026   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19027 for as_dir in $PATH
19028 do
19029   IFS=$as_save_IFS
19030   test -z "$as_dir" && as_dir=.
19031     for ac_exec_ext in '' $ac_executable_extensions; do
19032   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19033     ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
19034     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19035     break 2
19036   fi
19037 done
19038   done
19039 IFS=$as_save_IFS
19040 
19041   ;;
19042 esac
19043 fi
19044 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
19045 if test -n "$ac_pt_PKG_CONFIG"; then
19046   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
19047 $as_echo "$ac_pt_PKG_CONFIG" >&6; }
19048 else
19049   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19050 $as_echo "no" >&6; }
19051 fi
19052 
19053   if test "x$ac_pt_PKG_CONFIG" = x; then
19054     PKG_CONFIG=""
19055   else
19056     case $cross_compiling:$ac_tool_warned in
19057 yes:)
19058 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
19059 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
19060 ac_tool_warned=yes ;;
19061 esac
19062     PKG_CONFIG=$ac_pt_PKG_CONFIG
19063   fi
19064 else
19065   PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
19066 fi
19067 
19068 fi
19069 if test -n "$PKG_CONFIG"; then
19070         _pkg_min_version=0.9.0
19071         { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
19072 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
19073         if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
19074                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19075 $as_echo "yes" >&6; }
19076         else
19077                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19078 $as_echo "no" >&6; }
19079                 PKG_CONFIG=""
19080         fi
19081 
19082 fi
19083 
19084 # After basic tools have been setup, we can check build os specific details.
19085 
19086   ###############################################################################
19087 
19088   # Note that this is the build platform OS version!
19089 
19090   OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`"
19091   OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`"
19092   OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`"
19093   OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`"
19094 
19095 
19096 
19097 
19098 
19099 # Setup builddeps, for automatic downloading of tools we need.
19100 # This is needed before we can call BDEPS_CHECK_MODULE, which is done in
19101 # boot-jdk setup, but we need to have basic tools setup first.
19102 
19103 
19104 # Check whether --with-builddeps-conf was given.
19105 if test "${with_builddeps_conf+set}" = set; then :
19106   withval=$with_builddeps_conf;
19107 fi
19108 
19109 
19110 
19111 # Check whether --with-builddeps-server was given.
19112 if test "${with_builddeps_server+set}" = set; then :
19113   withval=$with_builddeps_server;
19114 fi
19115 
19116 
19117 
19118 # Check whether --with-builddeps-dir was given.
19119 if test "${with_builddeps_dir+set}" = set; then :
19120   withval=$with_builddeps_dir;
19121 else
19122   with_builddeps_dir=/localhome/builddeps
19123 fi
19124 
19125 
19126 
19127 # Check whether --with-builddeps-group was given.
19128 if test "${with_builddeps_group+set}" = set; then :
19129   withval=$with_builddeps_group;
19130 fi
19131 
19132 
19133 
19134 
19135   if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
19136     if test "x$with_builddeps_conf" != x; then
19137       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for supplied builddeps configuration file" >&5
19138 $as_echo_n "checking for supplied builddeps configuration file... " >&6; }
19139       builddepsfile=$with_builddeps_conf
19140       if test -s $builddepsfile; then
19141         . $builddepsfile
19142         { $as_echo "$as_me:${as_lineno-$LINENO}: result: loaded!" >&5
19143 $as_echo "loaded!" >&6; }
19144       else
19145         as_fn_error $? "The given builddeps conf file $with_builddeps_conf could not be loaded!" "$LINENO" 5
19146       fi
19147     else
19148       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for builddeps.conf files in sources..." >&5
19149 $as_echo_n "checking for builddeps.conf files in sources...... " >&6; }
19150       builddepsfile=`mktemp`
19151       touch $builddepsfile
19152       # Put all found confs into a single file.
19153       find ${SRC_ROOT} -name builddeps.conf -exec cat \{\} \; >> $builddepsfile
19154       # Source the file to acquire the variables
19155       if test -s $builddepsfile; then
19156         . $builddepsfile
19157         { $as_echo "$as_me:${as_lineno-$LINENO}: result: found at least one!" >&5
19158 $as_echo "found at least one!" >&6; }
19159       else
19160         as_fn_error $? "Could not find any builddeps.conf at all!" "$LINENO" 5
19161       fi
19162     fi
19163     # Create build and target names that use _ instead of "-" and ".".
19164     # This is necessary to use them in variable names.
19165     build_var=`echo ${OPENJDK_BUILD_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19166     target_var=`echo ${OPENJDK_TARGET_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19167     # Extract rewrite information for build and target
19168     eval rewritten_build=\${REWRITE_${build_var}}
19169     if test "x$rewritten_build" = x; then
19170       rewritten_build=${OPENJDK_BUILD_AUTOCONF_NAME}
19171       echo Build stays the same $rewritten_build
19172     else
19173       echo Rewriting build for builddeps into $rewritten_build
19174     fi
19175     eval rewritten_target=\${REWRITE_${target_var}}
19176     if test "x$rewritten_target" = x; then
19177       rewritten_target=${OPENJDK_TARGET_AUTOCONF_NAME}
19178       echo Target stays the same $rewritten_target
19179     else
19180       echo Rewriting target for builddeps into $rewritten_target
19181     fi
19182     rewritten_build_var=`echo ${rewritten_build} | tr '-' '_' | tr '.' '_'`
19183     rewritten_target_var=`echo ${rewritten_target} | tr '-' '_' | tr '.' '_'`
19184   fi
19185   for ac_prog in 7z unzip
19186 do
19187   # Extract the first word of "$ac_prog", so it can be a program name with args.
19188 set dummy $ac_prog; ac_word=$2
19189 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19190 $as_echo_n "checking for $ac_word... " >&6; }
19191 if ${ac_cv_prog_BDEPS_UNZIP+:} false; then :
19192   $as_echo_n "(cached) " >&6
19193 else
19194   if test -n "$BDEPS_UNZIP"; then
19195   ac_cv_prog_BDEPS_UNZIP="$BDEPS_UNZIP" # Let the user override the test.
19196 else
19197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19198 for as_dir in $PATH
19199 do
19200   IFS=$as_save_IFS
19201   test -z "$as_dir" && as_dir=.
19202     for ac_exec_ext in '' $ac_executable_extensions; do
19203   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19204     ac_cv_prog_BDEPS_UNZIP="$ac_prog"
19205     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19206     break 2
19207   fi
19208 done
19209   done
19210 IFS=$as_save_IFS
19211 
19212 fi
19213 fi
19214 BDEPS_UNZIP=$ac_cv_prog_BDEPS_UNZIP
19215 if test -n "$BDEPS_UNZIP"; then
19216   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_UNZIP" >&5
19217 $as_echo "$BDEPS_UNZIP" >&6; }
19218 else
19219   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19220 $as_echo "no" >&6; }
19221 fi
19222 
19223 
19224   test -n "$BDEPS_UNZIP" && break
19225 done
19226 
19227   if test "x$BDEPS_UNZIP" = x7z; then
19228     BDEPS_UNZIP="7z x"
19229   fi
19230 
19231   for ac_prog in wget lftp ftp
19232 do
19233   # Extract the first word of "$ac_prog", so it can be a program name with args.
19234 set dummy $ac_prog; ac_word=$2
19235 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19236 $as_echo_n "checking for $ac_word... " >&6; }
19237 if ${ac_cv_prog_BDEPS_FTP+:} false; then :
19238   $as_echo_n "(cached) " >&6
19239 else
19240   if test -n "$BDEPS_FTP"; then
19241   ac_cv_prog_BDEPS_FTP="$BDEPS_FTP" # Let the user override the test.
19242 else
19243 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19244 for as_dir in $PATH
19245 do
19246   IFS=$as_save_IFS
19247   test -z "$as_dir" && as_dir=.
19248     for ac_exec_ext in '' $ac_executable_extensions; do
19249   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19250     ac_cv_prog_BDEPS_FTP="$ac_prog"
19251     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19252     break 2
19253   fi
19254 done
19255   done
19256 IFS=$as_save_IFS
19257 
19258 fi
19259 fi
19260 BDEPS_FTP=$ac_cv_prog_BDEPS_FTP
19261 if test -n "$BDEPS_FTP"; then
19262   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_FTP" >&5
19263 $as_echo "$BDEPS_FTP" >&6; }
19264 else
19265   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19266 $as_echo "no" >&6; }
19267 fi
19268 
19269 
19270   test -n "$BDEPS_FTP" && break
19271 done
19272 
19273 
19274 
19275 ###############################################################################
19276 #
19277 # Determine OpenJDK variants, options and version numbers.
19278 #
19279 ###############################################################################
19280 
19281 # We need build & target for this.
19282 
19283 
19284   ###############################################################################
19285   #
19286   # Should we build a JDK/JVM with headful support (ie a graphical ui)?
19287   # We always build headless support.
19288   #
19289   { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
19290 $as_echo_n "checking headful support... " >&6; }
19291   # Check whether --enable-headful was given.
19292 if test "${enable_headful+set}" = set; then :
19293   enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
19294 else
19295   SUPPORT_HEADFUL=yes
19296 fi
19297 
19298 
19299   SUPPORT_HEADLESS=yes
19300   BUILD_HEADLESS="BUILD_HEADLESS:=true"
19301 
19302   if test "x$SUPPORT_HEADFUL" = xyes; then
19303     # We are building both headful and headless.
19304     headful_msg="include support for both headful and headless"
19305   fi
19306 
19307   if test "x$SUPPORT_HEADFUL" = xno; then
19308     # Thus we are building headless only.
19309     BUILD_HEADLESS="BUILD_HEADLESS:=true"
19310     headful_msg="headless only"
19311   fi
19312 
19313   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
19314 $as_echo "$headful_msg" >&6; }
19315 
19316 
19317 
19318 
19319 
19320   # Control wether Hotspot runs Queens test after build.
19321   # Check whether --enable-hotspot-test-in-build was given.
19322 if test "${enable_hotspot_test_in_build+set}" = set; then :
19323   enableval=$enable_hotspot_test_in_build;
19324 else
19325   enable_hotspot_test_in_build=no
19326 fi
19327 
19328   if test "x$enable_hotspot_test_in_build" = "xyes"; then
19329     TEST_IN_BUILD=true
19330   else
19331     TEST_IN_BUILD=false
19332   fi
19333 
19334 
19335   ###############################################################################
19336   #
19337   # Choose cacerts source file
19338   #
19339 
19340 # Check whether --with-cacerts-file was given.
19341 if test "${with_cacerts_file+set}" = set; then :
19342   withval=$with_cacerts_file;
19343 fi
19344 
19345   if test "x$with_cacerts_file" != x; then
19346     CACERTS_FILE=$with_cacerts_file
19347   else
19348     CACERTS_FILE=${SRC_ROOT}/jdk/src/share/lib/security/cacerts
19349   fi
19350 
19351 
19352   ###############################################################################
19353   #
19354   # Enable or disable unlimited crypto
19355   #
19356   # Check whether --enable-unlimited-crypto was given.
19357 if test "${enable_unlimited_crypto+set}" = set; then :
19358   enableval=$enable_unlimited_crypto;
19359 else
19360   enable_unlimited_crypto=no
19361 fi
19362 
19363   if test "x$enable_unlimited_crypto" = "xyes"; then
19364     UNLIMITED_CRYPTO=true
19365   else
19366     UNLIMITED_CRYPTO=false
19367   fi
19368 
19369 
19370   ###############################################################################
19371   #
19372   # Enable or disable the elliptic curve crypto implementation
19373   #
19374 
19375 
19376   ###############################################################################
19377   #
19378   # Compress jars
19379   #
19380   COMPRESS_JARS=false
19381 
19382 
19383 
19384 
19385   # Source the version numbers
19386   . $AUTOCONF_DIR/version-numbers
19387 
19388   # Get the settings from parameters
19389 
19390 # Check whether --with-milestone was given.
19391 if test "${with_milestone+set}" = set; then :
19392   withval=$with_milestone;
19393 fi
19394 
19395   if test "x$with_milestone" = xyes; then
19396     as_fn_error $? "Milestone must have a value" "$LINENO" 5
19397   elif test "x$with_milestone" != x; then
19398     MILESTONE="$with_milestone"
19399   fi
19400   if test "x$MILESTONE" = x; then
19401     MILESTONE=internal
19402   fi
19403 
19404 
19405 # Check whether --with-update-version was given.
19406 if test "${with_update_version+set}" = set; then :
19407   withval=$with_update_version;
19408 fi
19409 
19410   if test "x$with_update_version" = xyes; then
19411     as_fn_error $? "Update version must have a value" "$LINENO" 5
19412   elif test "x$with_update_version" != x; then
19413     JDK_UPDATE_VERSION="$with_update_version"
19414     # On macosx 10.7, it's not possible to set --with-update-version=0X due
19415     # to a bug in expr (which reduces it to just X). To work around this, we
19416     # always add a 0 to one digit update versions.
19417     if test "${#JDK_UPDATE_VERSION}" = "1"; then
19418       JDK_UPDATE_VERSION="0${JDK_UPDATE_VERSION}"
19419     fi
19420   fi
19421 
19422 
19423 # Check whether --with-user-release-suffix was given.
19424 if test "${with_user_release_suffix+set}" = set; then :
19425   withval=$with_user_release_suffix;
19426 fi
19427 
19428   if test "x$with_user_release_suffix" = xyes; then
19429     as_fn_error $? "Release suffix must have a value" "$LINENO" 5
19430   elif test "x$with_user_release_suffix" != x; then
19431     USER_RELEASE_SUFFIX="$with_user_release_suffix"
19432   fi
19433 
19434 
19435 # Check whether --with-build-number was given.
19436 if test "${with_build_number+set}" = set; then :
19437   withval=$with_build_number;
19438 fi
19439 
19440   if test "x$with_build_number" = xyes; then
19441     as_fn_error $? "Build number must have a value" "$LINENO" 5
19442   elif test "x$with_build_number" != x; then
19443     JDK_BUILD_NUMBER="$with_build_number"
19444   fi
19445   # Define default USER_RELEASE_SUFFIX if BUILD_NUMBER and USER_RELEASE_SUFFIX are not set
19446   if test "x$JDK_BUILD_NUMBER" = x; then
19447     JDK_BUILD_NUMBER=b00
19448     if test "x$USER_RELEASE_SUFFIX" = x; then
19449       BUILD_DATE=`date '+%Y_%m_%d_%H_%M'`
19450       # Avoid [:alnum:] since it depends on the locale.
19451       CLEAN_USERNAME=`echo "$USER" | $TR -d -c 'abcdefghijklmnopqrstuvqxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'`
19452       USER_RELEASE_SUFFIX=`echo "${CLEAN_USERNAME}_${BUILD_DATE}" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19453     fi
19454   fi
19455 
19456   # Now set the JDK version, milestone, build number etc.
19457 
19458 
19459 
19460 
19461 
19462 
19463 
19464 
19465 
19466 
19467 
19468 
19469 
19470 
19471 
19472   COPYRIGHT_YEAR=`date +'%Y'`
19473 
19474 
19475   if test "x$JDK_UPDATE_VERSION" != x; then
19476     JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}_${JDK_UPDATE_VERSION}"
19477   else
19478     JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}"
19479   fi
19480 
19481 
19482   COOKED_BUILD_NUMBER=`$ECHO $JDK_BUILD_NUMBER | $SED -e 's/^b//' -e 's/^0//'`
19483 
19484 
19485 
19486 ###############################################################################
19487 #
19488 # Setup BootJDK, used to bootstrap the build.
19489 #
19490 ###############################################################################
19491 
19492 
19493   BOOT_JDK_FOUND=no
19494 
19495 # Check whether --with-boot-jdk was given.
19496 if test "${with_boot_jdk+set}" = set; then :
19497   withval=$with_boot_jdk;
19498 fi
19499 
19500 
19501   # We look for the Boot JDK through various means, going from more certain to
19502   # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
19503   # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
19504   # must check if this is indeed valid; otherwise we'll continue looking.
19505 
19506   # Test: Is bootjdk explicitely set by command line arguments?
19507 
19508   if test "x$BOOT_JDK_FOUND" = xno; then
19509     # Now execute the test
19510 
19511   if test "x$with_boot_jdk" != x; then
19512     BOOT_JDK=$with_boot_jdk
19513     BOOT_JDK_FOUND=maybe
19514     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
19515 $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
19516   fi
19517 
19518 
19519     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
19520     if test "x$BOOT_JDK_FOUND" = xmaybe; then
19521       # Do we have a bin/java?
19522       if test ! -x "$BOOT_JDK/bin/java"; then
19523         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
19524 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
19525         BOOT_JDK_FOUND=no
19526       else
19527         # Do we have a bin/javac?
19528         if test ! -x "$BOOT_JDK/bin/javac"; then
19529           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
19530 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
19531           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
19532 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
19533           BOOT_JDK_FOUND=no
19534         else
19535           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
19536           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
19537             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
19538 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
19539             BOOT_JDK_FOUND=no
19540           else
19541             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
19542             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
19543 
19544             # Extra M4 quote needed to protect [] in grep expression.
19545             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
19546             if test "x$FOUND_CORRECT_VERSION" = x; then
19547               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
19548 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
19549               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
19550 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
19551               BOOT_JDK_FOUND=no
19552             else
19553               # We're done! :-)
19554               BOOT_JDK_FOUND=yes
19555 
19556   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19557 
19558   # Input might be given as Windows format, start by converting to
19559   # unix format.
19560   path="$BOOT_JDK"
19561   new_path=`$CYGPATH -u "$path"`
19562 
19563   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19564   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19565   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19566   # "foo.exe" is OK but "foo" is an error.
19567   #
19568   # This test is therefore slightly more accurate than "test -f" to check for file precense.
19569   # It is also a way to make sure we got the proper file name for the real test later on.
19570   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19571   if test "x$test_shortpath" = x; then
19572     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
19573 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
19574     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
19575   fi
19576 
19577   # Call helper function which possibly converts this using DOS-style short mode.
19578   # If so, the updated path is stored in $new_path.
19579 
19580   input_path="$new_path"
19581   # Check if we need to convert this using DOS-style short mode. If the path
19582   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19583   # take no chances and rewrite it.
19584   # Note: m4 eats our [], so we need to use [ and ] instead.
19585   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19586   if test "x$has_forbidden_chars" != x; then
19587     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19588     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19589     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19590     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19591       # Going to short mode and back again did indeed matter. Since short mode is
19592       # case insensitive, let's make it lowercase to improve readability.
19593       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19594       # Now convert it back to Unix-stile (cygpath)
19595       input_path=`$CYGPATH -u "$shortmode_path"`
19596       new_path="$input_path"
19597     fi
19598   fi
19599 
19600   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19601   if test "x$test_cygdrive_prefix" = x; then
19602     # As a simple fix, exclude /usr/bin since it's not a real path.
19603     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
19604       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19605       # a path prefixed by /cygdrive for fixpath to work.
19606       new_path="$CYGWIN_ROOT_PATH$input_path"
19607     fi
19608   fi
19609 
19610 
19611   if test "x$path" != "x$new_path"; then
19612     BOOT_JDK="$new_path"
19613     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
19614 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
19615   fi
19616 
19617   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19618 
19619   path="$BOOT_JDK"
19620   has_colon=`$ECHO $path | $GREP ^.:`
19621   new_path="$path"
19622   if test "x$has_colon" = x; then
19623     # Not in mixed or Windows style, start by that.
19624     new_path=`cmd //c echo $path`
19625   fi
19626 
19627 
19628   input_path="$new_path"
19629   # Check if we need to convert this using DOS-style short mode. If the path
19630   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19631   # take no chances and rewrite it.
19632   # Note: m4 eats our [], so we need to use [ and ] instead.
19633   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
19634   if test "x$has_forbidden_chars" != x; then
19635     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19636     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19637   fi
19638 
19639 
19640   windows_path="$new_path"
19641   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19642     unix_path=`$CYGPATH -u "$windows_path"`
19643     new_path="$unix_path"
19644   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19645     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19646     new_path="$unix_path"
19647   fi
19648 
19649   if test "x$path" != "x$new_path"; then
19650     BOOT_JDK="$new_path"
19651     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
19652 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
19653   fi
19654 
19655   # Save the first 10 bytes of this path to the storage, so fixpath can work.
19656   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19657 
19658   else
19659     # We're on a posix platform. Hooray! :)
19660     path="$BOOT_JDK"
19661     has_space=`$ECHO "$path" | $GREP " "`
19662     if test "x$has_space" != x; then
19663       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
19664 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
19665       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
19666     fi
19667 
19668     # Use eval to expand a potential ~
19669     eval path="$path"
19670     if test ! -f "$path" && test ! -d "$path"; then
19671       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
19672     fi
19673 
19674     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
19675   fi
19676 
19677               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
19678 $as_echo_n "checking for Boot JDK... " >&6; }
19679               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
19680 $as_echo "$BOOT_JDK" >&6; }
19681               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
19682 $as_echo_n "checking Boot JDK version... " >&6; }
19683               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
19684               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
19685 $as_echo "$BOOT_JDK_VERSION" >&6; }
19686             fi # end check jdk version
19687           fi # end check rt.jar
19688         fi # end check javac
19689       fi # end check java
19690     fi # end check boot jdk found
19691   fi
19692 
19693   if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
19694     # Having specified an argument which is incorrect will produce an instant failure;
19695     # we should not go on looking
19696     as_fn_error $? "The path given by --with-boot-jdk does not contain a valid Boot JDK" "$LINENO" 5
19697   fi
19698 
19699   # Test: Is bootjdk available from builddeps?
19700 
19701   if test "x$BOOT_JDK_FOUND" = xno; then
19702     # Now execute the test
19703 
19704 
19705 
19706   if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
19707     # Source the builddeps file again, to make sure it uses the latest variables!
19708     . $builddepsfile
19709     # Look for a target and build machine specific resource!
19710     eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}_TARGET_${rewritten_target_var}}
19711     if test "x$resource" = x; then
19712       # Ok, lets instead look for a target specific resource
19713       eval resource=\${builddep_bootjdk_TARGET_${rewritten_target_var}}
19714     fi
19715     if test "x$resource" = x; then
19716       # Ok, lets instead look for a build specific resource
19717       eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}}
19718     fi
19719     if test "x$resource" = x; then
19720       # Ok, lets instead look for a generic resource
19721       # (The bootjdk comes from M4 and not the shell, thus no need for eval here.)
19722       resource=${builddep_bootjdk}
19723     fi
19724     if test "x$resource" != x; then
19725       { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for bootjdk" >&5
19726 $as_echo "$as_me: Using builddeps $resource for bootjdk" >&6;}
19727       # If the resource in the builddeps.conf file is an existing directory,
19728       # for example /java/linux/cups
19729       if test -d ${resource}; then
19730         depdir=${resource}
19731       else
19732 
19733   # bootjdk is for example mymodule
19734   # $resource is for example libs/general/libmymod_1_2_3.zip
19735   # $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps
19736   # $with_builddeps_dir is for example /localhome/builddeps
19737   # depdir is the name of the variable into which we store the depdir, eg MYMOD
19738   # Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and
19739   # unzip into the directory: /localhome/builddeps/libmymod_1_2_3
19740   filename=`basename $resource`
19741   filebase=`echo $filename | sed 's/\.[^\.]*$//'`
19742   filebase=${filename%%.*}
19743   extension=${filename#*.}
19744   installdir=$with_builddeps_dir/$filebase
19745   if test ! -f $installdir/$filename.unpacked; then
19746     { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&5
19747 $as_echo "$as_me: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&6;}
19748     if test ! -d $installdir; then
19749       mkdir -p $installdir
19750     fi
19751     if test ! -d $installdir; then
19752       as_fn_error $? "Could not create directory $installdir" "$LINENO" 5
19753     fi
19754     tmpfile=`mktemp $installdir/bootjdk.XXXXXXXXX`
19755     touch $tmpfile
19756     if test ! -f $tmpfile; then
19757       as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5
19758     fi
19759 
19760   # $with_builddeps_server/$resource  is the ftp://abuilddeps.server.com/libs/cups.zip
19761   # $tmpfile is the local file name for the downloaded file.
19762   VALID_TOOL=no
19763   if test "x$BDEPS_FTP" = xwget; then
19764     VALID_TOOL=yes
19765     wget -O $tmpfile $with_builddeps_server/$resource
19766   fi
19767   if test "x$BDEPS_FTP" = xlftp; then
19768     VALID_TOOL=yes
19769     lftp -c "get $with_builddeps_server/$resource  -o $tmpfile"
19770   fi
19771   if test "x$BDEPS_FTP" = xftp; then
19772     VALID_TOOL=yes
19773     FTPSERVER=`echo $with_builddeps_server/$resource  | cut -f 3 -d '/'`
19774     FTPPATH=`echo $with_builddeps_server/$resource  | cut -f 4- -d '/'`
19775     FTPUSERPWD=${FTPSERVER%%@*}
19776     if test "x$FTPSERVER" != "x$FTPUSERPWD"; then
19777       FTPUSER=${userpwd%%:*}
19778       FTPPWD=${userpwd#*@}
19779       FTPSERVER=${FTPSERVER#*@}
19780     else
19781       FTPUSER=ftp
19782       FTPPWD=ftp
19783     fi
19784     # the "pass" command does not work on some
19785     # ftp clients (read ftp.exe) but if it works,
19786     # passive mode is better!
19787     ( \
19788         echo "user $FTPUSER $FTPPWD"        ; \
19789         echo "pass"                         ; \
19790         echo "bin"                          ; \
19791         echo "get $FTPPATH $tmpfile"              ; \
19792     ) | ftp -in $FTPSERVER
19793   fi
19794   if test "x$VALID_TOOL" != xyes; then
19795     as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5
19796   fi
19797 
19798     mv $tmpfile $installdir/$filename
19799     if test ! -s $installdir/$filename; then
19800       as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5
19801     fi
19802     case "$extension" in
19803       zip)  echo "Unzipping $installdir/$filename..."
19804         (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked)
19805         ;;
19806       tar.gz) echo "Untaring $installdir/$filename..."
19807         (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
19808         ;;
19809       tgz) echo "Untaring $installdir/$filename..."
19810         (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
19811         ;;
19812       *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5
19813         ;;
19814     esac
19815   fi
19816   if test -f $installdir/$filename.unpacked; then
19817     depdir=$installdir
19818   fi
19819 
19820       fi
19821       # Source the builddeps file again, because in the previous command, the depdir
19822       # was updated to point at the current build dependency install directory.
19823       . $builddepsfile
19824       # Now extract variables from the builddeps.conf files.
19825       theroot=${builddep_bootjdk_ROOT}
19826       thecflags=${builddep_bootjdk_CFLAGS}
19827       thelibs=${builddep_bootjdk_LIBS}
19828       if test "x$depdir" = x; then
19829         as_fn_error $? "Could not download build dependency bootjdk" "$LINENO" 5
19830       fi
19831       BOOT_JDK=$depdir
19832       if test "x$theroot" != x; then
19833         BOOT_JDK="$theroot"
19834       fi
19835       if test "x$thecflags" != x; then
19836         BOOT_JDK_CFLAGS="$thecflags"
19837       fi
19838       if test "x$thelibs" != x; then
19839         BOOT_JDK_LIBS="$thelibs"
19840       fi
19841       BOOT_JDK_FOUND=maybe
19842       else BOOT_JDK_FOUND=no
19843 
19844     fi
19845     else BOOT_JDK_FOUND=no
19846 
19847   fi
19848 
19849 
19850 
19851     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
19852     if test "x$BOOT_JDK_FOUND" = xmaybe; then
19853       # Do we have a bin/java?
19854       if test ! -x "$BOOT_JDK/bin/java"; then
19855         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
19856 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
19857         BOOT_JDK_FOUND=no
19858       else
19859         # Do we have a bin/javac?
19860         if test ! -x "$BOOT_JDK/bin/javac"; then
19861           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
19862 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
19863           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
19864 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
19865           BOOT_JDK_FOUND=no
19866         else
19867           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
19868           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
19869             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
19870 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
19871             BOOT_JDK_FOUND=no
19872           else
19873             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
19874             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
19875 
19876             # Extra M4 quote needed to protect [] in grep expression.
19877             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
19878             if test "x$FOUND_CORRECT_VERSION" = x; then
19879               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
19880 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
19881               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
19882 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
19883               BOOT_JDK_FOUND=no
19884             else
19885               # We're done! :-)
19886               BOOT_JDK_FOUND=yes
19887 
19888   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19889 
19890   # Input might be given as Windows format, start by converting to
19891   # unix format.
19892   path="$BOOT_JDK"
19893   new_path=`$CYGPATH -u "$path"`
19894 
19895   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19896   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19897   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19898   # "foo.exe" is OK but "foo" is an error.
19899   #
19900   # This test is therefore slightly more accurate than "test -f" to check for file precense.
19901   # It is also a way to make sure we got the proper file name for the real test later on.
19902   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19903   if test "x$test_shortpath" = x; then
19904     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
19905 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
19906     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
19907   fi
19908 
19909   # Call helper function which possibly converts this using DOS-style short mode.
19910   # If so, the updated path is stored in $new_path.
19911 
19912   input_path="$new_path"
19913   # Check if we need to convert this using DOS-style short mode. If the path
19914   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19915   # take no chances and rewrite it.
19916   # Note: m4 eats our [], so we need to use [ and ] instead.
19917   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19918   if test "x$has_forbidden_chars" != x; then
19919     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19920     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19921     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19922     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19923       # Going to short mode and back again did indeed matter. Since short mode is
19924       # case insensitive, let's make it lowercase to improve readability.
19925       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19926       # Now convert it back to Unix-stile (cygpath)
19927       input_path=`$CYGPATH -u "$shortmode_path"`
19928       new_path="$input_path"
19929     fi
19930   fi
19931 
19932   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19933   if test "x$test_cygdrive_prefix" = x; then
19934     # As a simple fix, exclude /usr/bin since it's not a real path.
19935     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
19936       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19937       # a path prefixed by /cygdrive for fixpath to work.
19938       new_path="$CYGWIN_ROOT_PATH$input_path"
19939     fi
19940   fi
19941 
19942 
19943   if test "x$path" != "x$new_path"; then
19944     BOOT_JDK="$new_path"
19945     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
19946 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
19947   fi
19948 
19949   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19950 
19951   path="$BOOT_JDK"
19952   has_colon=`$ECHO $path | $GREP ^.:`
19953   new_path="$path"
19954   if test "x$has_colon" = x; then
19955     # Not in mixed or Windows style, start by that.
19956     new_path=`cmd //c echo $path`
19957   fi
19958 
19959 
19960   input_path="$new_path"
19961   # Check if we need to convert this using DOS-style short mode. If the path
19962   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19963   # take no chances and rewrite it.
19964   # Note: m4 eats our [], so we need to use [ and ] instead.
19965   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
19966   if test "x$has_forbidden_chars" != x; then
19967     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19968     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19969   fi
19970 
19971 
19972   windows_path="$new_path"
19973   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19974     unix_path=`$CYGPATH -u "$windows_path"`
19975     new_path="$unix_path"
19976   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19977     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19978     new_path="$unix_path"
19979   fi
19980 
19981   if test "x$path" != "x$new_path"; then
19982     BOOT_JDK="$new_path"
19983     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
19984 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
19985   fi
19986 
19987   # Save the first 10 bytes of this path to the storage, so fixpath can work.
19988   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19989 
19990   else
19991     # We're on a posix platform. Hooray! :)
19992     path="$BOOT_JDK"
19993     has_space=`$ECHO "$path" | $GREP " "`
19994     if test "x$has_space" != x; then
19995       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
19996 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
19997       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
19998     fi
19999 
20000     # Use eval to expand a potential ~
20001     eval path="$path"
20002     if test ! -f "$path" && test ! -d "$path"; then
20003       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20004     fi
20005 
20006     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20007   fi
20008 
20009               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20010 $as_echo_n "checking for Boot JDK... " >&6; }
20011               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20012 $as_echo "$BOOT_JDK" >&6; }
20013               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20014 $as_echo_n "checking Boot JDK version... " >&6; }
20015               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20016               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20017 $as_echo "$BOOT_JDK_VERSION" >&6; }
20018             fi # end check jdk version
20019           fi # end check rt.jar
20020         fi # end check javac
20021       fi # end check java
20022     fi # end check boot jdk found
20023   fi
20024 
20025 
20026   # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
20027 
20028   if test "x$BOOT_JDK_FOUND" = xno; then
20029     # Now execute the test
20030 
20031   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
20032     # First check at user selected default
20033 
20034   if test "x$BOOT_JDK_FOUND" = xno; then
20035     # Now execute the test
20036 
20037   if test -x /usr/libexec/java_home; then
20038     BOOT_JDK=`/usr/libexec/java_home `
20039     BOOT_JDK_FOUND=maybe
20040     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home " >&5
20041 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home " >&6;}
20042   fi
20043 
20044 
20045     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20046     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20047       # Do we have a bin/java?
20048       if test ! -x "$BOOT_JDK/bin/java"; then
20049         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20050 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20051         BOOT_JDK_FOUND=no
20052       else
20053         # Do we have a bin/javac?
20054         if test ! -x "$BOOT_JDK/bin/javac"; then
20055           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20056 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20057           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20058 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20059           BOOT_JDK_FOUND=no
20060         else
20061           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20062           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20063             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20064 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20065             BOOT_JDK_FOUND=no
20066           else
20067             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20068             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20069 
20070             # Extra M4 quote needed to protect [] in grep expression.
20071             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
20072             if test "x$FOUND_CORRECT_VERSION" = x; then
20073               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20074 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20075               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
20076 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
20077               BOOT_JDK_FOUND=no
20078             else
20079               # We're done! :-)
20080               BOOT_JDK_FOUND=yes
20081 
20082   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20083 
20084   # Input might be given as Windows format, start by converting to
20085   # unix format.
20086   path="$BOOT_JDK"
20087   new_path=`$CYGPATH -u "$path"`
20088 
20089   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20090   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20091   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20092   # "foo.exe" is OK but "foo" is an error.
20093   #
20094   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20095   # It is also a way to make sure we got the proper file name for the real test later on.
20096   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20097   if test "x$test_shortpath" = x; then
20098     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20099 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20100     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20101   fi
20102 
20103   # Call helper function which possibly converts this using DOS-style short mode.
20104   # If so, the updated path is stored in $new_path.
20105 
20106   input_path="$new_path"
20107   # Check if we need to convert this using DOS-style short mode. If the path
20108   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20109   # take no chances and rewrite it.
20110   # Note: m4 eats our [], so we need to use [ and ] instead.
20111   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20112   if test "x$has_forbidden_chars" != x; then
20113     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20114     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20115     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20116     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20117       # Going to short mode and back again did indeed matter. Since short mode is
20118       # case insensitive, let's make it lowercase to improve readability.
20119       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20120       # Now convert it back to Unix-stile (cygpath)
20121       input_path=`$CYGPATH -u "$shortmode_path"`
20122       new_path="$input_path"
20123     fi
20124   fi
20125 
20126   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20127   if test "x$test_cygdrive_prefix" = x; then
20128     # As a simple fix, exclude /usr/bin since it's not a real path.
20129     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20130       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20131       # a path prefixed by /cygdrive for fixpath to work.
20132       new_path="$CYGWIN_ROOT_PATH$input_path"
20133     fi
20134   fi
20135 
20136 
20137   if test "x$path" != "x$new_path"; then
20138     BOOT_JDK="$new_path"
20139     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20140 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20141   fi
20142 
20143   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20144 
20145   path="$BOOT_JDK"
20146   has_colon=`$ECHO $path | $GREP ^.:`
20147   new_path="$path"
20148   if test "x$has_colon" = x; then
20149     # Not in mixed or Windows style, start by that.
20150     new_path=`cmd //c echo $path`
20151   fi
20152 
20153 
20154   input_path="$new_path"
20155   # Check if we need to convert this using DOS-style short mode. If the path
20156   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20157   # take no chances and rewrite it.
20158   # Note: m4 eats our [], so we need to use [ and ] instead.
20159   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20160   if test "x$has_forbidden_chars" != x; then
20161     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20162     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20163   fi
20164 
20165 
20166   windows_path="$new_path"
20167   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20168     unix_path=`$CYGPATH -u "$windows_path"`
20169     new_path="$unix_path"
20170   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20171     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20172     new_path="$unix_path"
20173   fi
20174 
20175   if test "x$path" != "x$new_path"; then
20176     BOOT_JDK="$new_path"
20177     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20178 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20179   fi
20180 
20181   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20182   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20183 
20184   else
20185     # We're on a posix platform. Hooray! :)
20186     path="$BOOT_JDK"
20187     has_space=`$ECHO "$path" | $GREP " "`
20188     if test "x$has_space" != x; then
20189       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20190 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20191       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20192     fi
20193 
20194     # Use eval to expand a potential ~
20195     eval path="$path"
20196     if test ! -f "$path" && test ! -d "$path"; then
20197       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20198     fi
20199 
20200     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20201   fi
20202 
20203               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20204 $as_echo_n "checking for Boot JDK... " >&6; }
20205               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20206 $as_echo "$BOOT_JDK" >&6; }
20207               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20208 $as_echo_n "checking Boot JDK version... " >&6; }
20209               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20210               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20211 $as_echo "$BOOT_JDK_VERSION" >&6; }
20212             fi # end check jdk version
20213           fi # end check rt.jar
20214         fi # end check javac
20215       fi # end check java
20216     fi # end check boot jdk found
20217   fi
20218 
20219     # If that did not work out (e.g. too old), try explicit versions instead
20220 
20221   if test "x$BOOT_JDK_FOUND" = xno; then
20222     # Now execute the test
20223 
20224   if test -x /usr/libexec/java_home; then
20225     BOOT_JDK=`/usr/libexec/java_home -v 1.9`
20226     BOOT_JDK_FOUND=maybe
20227     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&5
20228 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&6;}
20229   fi
20230 
20231 
20232     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20233     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20234       # Do we have a bin/java?
20235       if test ! -x "$BOOT_JDK/bin/java"; then
20236         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20237 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20238         BOOT_JDK_FOUND=no
20239       else
20240         # Do we have a bin/javac?
20241         if test ! -x "$BOOT_JDK/bin/javac"; then
20242           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20243 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20244           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20245 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20246           BOOT_JDK_FOUND=no
20247         else
20248           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20249           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20250             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20251 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20252             BOOT_JDK_FOUND=no
20253           else
20254             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20255             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20256 
20257             # Extra M4 quote needed to protect [] in grep expression.
20258             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
20259             if test "x$FOUND_CORRECT_VERSION" = x; then
20260               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20261 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20262               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
20263 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
20264               BOOT_JDK_FOUND=no
20265             else
20266               # We're done! :-)
20267               BOOT_JDK_FOUND=yes
20268 
20269   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20270 
20271   # Input might be given as Windows format, start by converting to
20272   # unix format.
20273   path="$BOOT_JDK"
20274   new_path=`$CYGPATH -u "$path"`
20275 
20276   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20277   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20278   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20279   # "foo.exe" is OK but "foo" is an error.
20280   #
20281   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20282   # It is also a way to make sure we got the proper file name for the real test later on.
20283   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20284   if test "x$test_shortpath" = x; then
20285     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20286 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20287     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20288   fi
20289 
20290   # Call helper function which possibly converts this using DOS-style short mode.
20291   # If so, the updated path is stored in $new_path.
20292 
20293   input_path="$new_path"
20294   # Check if we need to convert this using DOS-style short mode. If the path
20295   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20296   # take no chances and rewrite it.
20297   # Note: m4 eats our [], so we need to use [ and ] instead.
20298   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20299   if test "x$has_forbidden_chars" != x; then
20300     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20301     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20302     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20303     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20304       # Going to short mode and back again did indeed matter. Since short mode is
20305       # case insensitive, let's make it lowercase to improve readability.
20306       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20307       # Now convert it back to Unix-stile (cygpath)
20308       input_path=`$CYGPATH -u "$shortmode_path"`
20309       new_path="$input_path"
20310     fi
20311   fi
20312 
20313   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20314   if test "x$test_cygdrive_prefix" = x; then
20315     # As a simple fix, exclude /usr/bin since it's not a real path.
20316     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20317       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20318       # a path prefixed by /cygdrive for fixpath to work.
20319       new_path="$CYGWIN_ROOT_PATH$input_path"
20320     fi
20321   fi
20322 
20323 
20324   if test "x$path" != "x$new_path"; then
20325     BOOT_JDK="$new_path"
20326     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20327 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20328   fi
20329 
20330   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20331 
20332   path="$BOOT_JDK"
20333   has_colon=`$ECHO $path | $GREP ^.:`
20334   new_path="$path"
20335   if test "x$has_colon" = x; then
20336     # Not in mixed or Windows style, start by that.
20337     new_path=`cmd //c echo $path`
20338   fi
20339 
20340 
20341   input_path="$new_path"
20342   # Check if we need to convert this using DOS-style short mode. If the path
20343   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20344   # take no chances and rewrite it.
20345   # Note: m4 eats our [], so we need to use [ and ] instead.
20346   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20347   if test "x$has_forbidden_chars" != x; then
20348     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20349     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20350   fi
20351 
20352 
20353   windows_path="$new_path"
20354   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20355     unix_path=`$CYGPATH -u "$windows_path"`
20356     new_path="$unix_path"
20357   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20358     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20359     new_path="$unix_path"
20360   fi
20361 
20362   if test "x$path" != "x$new_path"; then
20363     BOOT_JDK="$new_path"
20364     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20365 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20366   fi
20367 
20368   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20369   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20370 
20371   else
20372     # We're on a posix platform. Hooray! :)
20373     path="$BOOT_JDK"
20374     has_space=`$ECHO "$path" | $GREP " "`
20375     if test "x$has_space" != x; then
20376       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20377 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20378       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20379     fi
20380 
20381     # Use eval to expand a potential ~
20382     eval path="$path"
20383     if test ! -f "$path" && test ! -d "$path"; then
20384       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20385     fi
20386 
20387     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20388   fi
20389 
20390               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20391 $as_echo_n "checking for Boot JDK... " >&6; }
20392               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20393 $as_echo "$BOOT_JDK" >&6; }
20394               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20395 $as_echo_n "checking Boot JDK version... " >&6; }
20396               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20397               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20398 $as_echo "$BOOT_JDK_VERSION" >&6; }
20399             fi # end check jdk version
20400           fi # end check rt.jar
20401         fi # end check javac
20402       fi # end check java
20403     fi # end check boot jdk found
20404   fi
20405 
20406 
20407   if test "x$BOOT_JDK_FOUND" = xno; then
20408     # Now execute the test
20409 
20410   if test -x /usr/libexec/java_home; then
20411     BOOT_JDK=`/usr/libexec/java_home -v 1.8`
20412     BOOT_JDK_FOUND=maybe
20413     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&5
20414 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&6;}
20415   fi
20416 
20417 
20418     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20419     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20420       # Do we have a bin/java?
20421       if test ! -x "$BOOT_JDK/bin/java"; then
20422         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20423 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20424         BOOT_JDK_FOUND=no
20425       else
20426         # Do we have a bin/javac?
20427         if test ! -x "$BOOT_JDK/bin/javac"; then
20428           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20429 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20430           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20431 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20432           BOOT_JDK_FOUND=no
20433         else
20434           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20435           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20436             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20437 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20438             BOOT_JDK_FOUND=no
20439           else
20440             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20441             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20442 
20443             # Extra M4 quote needed to protect [] in grep expression.
20444             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
20445             if test "x$FOUND_CORRECT_VERSION" = x; then
20446               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20447 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20448               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
20449 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
20450               BOOT_JDK_FOUND=no
20451             else
20452               # We're done! :-)
20453               BOOT_JDK_FOUND=yes
20454 
20455   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20456 
20457   # Input might be given as Windows format, start by converting to
20458   # unix format.
20459   path="$BOOT_JDK"
20460   new_path=`$CYGPATH -u "$path"`
20461 
20462   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20463   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20464   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20465   # "foo.exe" is OK but "foo" is an error.
20466   #
20467   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20468   # It is also a way to make sure we got the proper file name for the real test later on.
20469   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20470   if test "x$test_shortpath" = x; then
20471     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20472 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20473     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20474   fi
20475 
20476   # Call helper function which possibly converts this using DOS-style short mode.
20477   # If so, the updated path is stored in $new_path.
20478 
20479   input_path="$new_path"
20480   # Check if we need to convert this using DOS-style short mode. If the path
20481   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20482   # take no chances and rewrite it.
20483   # Note: m4 eats our [], so we need to use [ and ] instead.
20484   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20485   if test "x$has_forbidden_chars" != x; then
20486     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20487     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20488     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20489     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20490       # Going to short mode and back again did indeed matter. Since short mode is
20491       # case insensitive, let's make it lowercase to improve readability.
20492       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20493       # Now convert it back to Unix-stile (cygpath)
20494       input_path=`$CYGPATH -u "$shortmode_path"`
20495       new_path="$input_path"
20496     fi
20497   fi
20498 
20499   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20500   if test "x$test_cygdrive_prefix" = x; then
20501     # As a simple fix, exclude /usr/bin since it's not a real path.
20502     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20503       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20504       # a path prefixed by /cygdrive for fixpath to work.
20505       new_path="$CYGWIN_ROOT_PATH$input_path"
20506     fi
20507   fi
20508 
20509 
20510   if test "x$path" != "x$new_path"; then
20511     BOOT_JDK="$new_path"
20512     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20513 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20514   fi
20515 
20516   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20517 
20518   path="$BOOT_JDK"
20519   has_colon=`$ECHO $path | $GREP ^.:`
20520   new_path="$path"
20521   if test "x$has_colon" = x; then
20522     # Not in mixed or Windows style, start by that.
20523     new_path=`cmd //c echo $path`
20524   fi
20525 
20526 
20527   input_path="$new_path"
20528   # Check if we need to convert this using DOS-style short mode. If the path
20529   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20530   # take no chances and rewrite it.
20531   # Note: m4 eats our [], so we need to use [ and ] instead.
20532   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20533   if test "x$has_forbidden_chars" != x; then
20534     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20535     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20536   fi
20537 
20538 
20539   windows_path="$new_path"
20540   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20541     unix_path=`$CYGPATH -u "$windows_path"`
20542     new_path="$unix_path"
20543   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20544     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20545     new_path="$unix_path"
20546   fi
20547 
20548   if test "x$path" != "x$new_path"; then
20549     BOOT_JDK="$new_path"
20550     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20551 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20552   fi
20553 
20554   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20555   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20556 
20557   else
20558     # We're on a posix platform. Hooray! :)
20559     path="$BOOT_JDK"
20560     has_space=`$ECHO "$path" | $GREP " "`
20561     if test "x$has_space" != x; then
20562       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20563 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20564       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20565     fi
20566 
20567     # Use eval to expand a potential ~
20568     eval path="$path"
20569     if test ! -f "$path" && test ! -d "$path"; then
20570       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20571     fi
20572 
20573     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20574   fi
20575 
20576               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20577 $as_echo_n "checking for Boot JDK... " >&6; }
20578               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20579 $as_echo "$BOOT_JDK" >&6; }
20580               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20581 $as_echo_n "checking Boot JDK version... " >&6; }
20582               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20583               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20584 $as_echo "$BOOT_JDK_VERSION" >&6; }
20585             fi # end check jdk version
20586           fi # end check rt.jar
20587         fi # end check javac
20588       fi # end check java
20589     fi # end check boot jdk found
20590   fi
20591 
20592 
20593   if test "x$BOOT_JDK_FOUND" = xno; then
20594     # Now execute the test
20595 
20596   if test -x /usr/libexec/java_home; then
20597     BOOT_JDK=`/usr/libexec/java_home -v 1.7`
20598     BOOT_JDK_FOUND=maybe
20599     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&5
20600 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&6;}
20601   fi
20602 
20603 
20604     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20605     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20606       # Do we have a bin/java?
20607       if test ! -x "$BOOT_JDK/bin/java"; then
20608         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20609 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20610         BOOT_JDK_FOUND=no
20611       else
20612         # Do we have a bin/javac?
20613         if test ! -x "$BOOT_JDK/bin/javac"; then
20614           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20615 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20616           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20617 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20618           BOOT_JDK_FOUND=no
20619         else
20620           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20621           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20622             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20623 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20624             BOOT_JDK_FOUND=no
20625           else
20626             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20627             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20628 
20629             # Extra M4 quote needed to protect [] in grep expression.
20630             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
20631             if test "x$FOUND_CORRECT_VERSION" = x; then
20632               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20633 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20634               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
20635 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
20636               BOOT_JDK_FOUND=no
20637             else
20638               # We're done! :-)
20639               BOOT_JDK_FOUND=yes
20640 
20641   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20642 
20643   # Input might be given as Windows format, start by converting to
20644   # unix format.
20645   path="$BOOT_JDK"
20646   new_path=`$CYGPATH -u "$path"`
20647 
20648   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20649   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20650   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20651   # "foo.exe" is OK but "foo" is an error.
20652   #
20653   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20654   # It is also a way to make sure we got the proper file name for the real test later on.
20655   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20656   if test "x$test_shortpath" = x; then
20657     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20658 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20659     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20660   fi
20661 
20662   # Call helper function which possibly converts this using DOS-style short mode.
20663   # If so, the updated path is stored in $new_path.
20664 
20665   input_path="$new_path"
20666   # Check if we need to convert this using DOS-style short mode. If the path
20667   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20668   # take no chances and rewrite it.
20669   # Note: m4 eats our [], so we need to use [ and ] instead.
20670   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20671   if test "x$has_forbidden_chars" != x; then
20672     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20673     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20674     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20675     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20676       # Going to short mode and back again did indeed matter. Since short mode is
20677       # case insensitive, let's make it lowercase to improve readability.
20678       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20679       # Now convert it back to Unix-stile (cygpath)
20680       input_path=`$CYGPATH -u "$shortmode_path"`
20681       new_path="$input_path"
20682     fi
20683   fi
20684 
20685   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20686   if test "x$test_cygdrive_prefix" = x; then
20687     # As a simple fix, exclude /usr/bin since it's not a real path.
20688     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20689       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20690       # a path prefixed by /cygdrive for fixpath to work.
20691       new_path="$CYGWIN_ROOT_PATH$input_path"
20692     fi
20693   fi
20694 
20695 
20696   if test "x$path" != "x$new_path"; then
20697     BOOT_JDK="$new_path"
20698     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20699 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20700   fi
20701 
20702   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20703 
20704   path="$BOOT_JDK"
20705   has_colon=`$ECHO $path | $GREP ^.:`
20706   new_path="$path"
20707   if test "x$has_colon" = x; then
20708     # Not in mixed or Windows style, start by that.
20709     new_path=`cmd //c echo $path`
20710   fi
20711 
20712 
20713   input_path="$new_path"
20714   # Check if we need to convert this using DOS-style short mode. If the path
20715   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20716   # take no chances and rewrite it.
20717   # Note: m4 eats our [], so we need to use [ and ] instead.
20718   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20719   if test "x$has_forbidden_chars" != x; then
20720     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20721     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20722   fi
20723 
20724 
20725   windows_path="$new_path"
20726   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20727     unix_path=`$CYGPATH -u "$windows_path"`
20728     new_path="$unix_path"
20729   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20730     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20731     new_path="$unix_path"
20732   fi
20733 
20734   if test "x$path" != "x$new_path"; then
20735     BOOT_JDK="$new_path"
20736     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20737 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20738   fi
20739 
20740   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20741   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20742 
20743   else
20744     # We're on a posix platform. Hooray! :)
20745     path="$BOOT_JDK"
20746     has_space=`$ECHO "$path" | $GREP " "`
20747     if test "x$has_space" != x; then
20748       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20749 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20750       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20751     fi
20752 
20753     # Use eval to expand a potential ~
20754     eval path="$path"
20755     if test ! -f "$path" && test ! -d "$path"; then
20756       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20757     fi
20758 
20759     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20760   fi
20761 
20762               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20763 $as_echo_n "checking for Boot JDK... " >&6; }
20764               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20765 $as_echo "$BOOT_JDK" >&6; }
20766               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20767 $as_echo_n "checking Boot JDK version... " >&6; }
20768               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20769               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20770 $as_echo "$BOOT_JDK_VERSION" >&6; }
20771             fi # end check jdk version
20772           fi # end check rt.jar
20773         fi # end check javac
20774       fi # end check java
20775     fi # end check boot jdk found
20776   fi
20777 
20778   fi
20779 
20780 
20781     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20782     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20783       # Do we have a bin/java?
20784       if test ! -x "$BOOT_JDK/bin/java"; then
20785         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20786 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20787         BOOT_JDK_FOUND=no
20788       else
20789         # Do we have a bin/javac?
20790         if test ! -x "$BOOT_JDK/bin/javac"; then
20791           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20792 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20793           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20794 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20795           BOOT_JDK_FOUND=no
20796         else
20797           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20798           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20799             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20800 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20801             BOOT_JDK_FOUND=no
20802           else
20803             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20804             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20805 
20806             # Extra M4 quote needed to protect [] in grep expression.
20807             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
20808             if test "x$FOUND_CORRECT_VERSION" = x; then
20809               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20810 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20811               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
20812 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
20813               BOOT_JDK_FOUND=no
20814             else
20815               # We're done! :-)
20816               BOOT_JDK_FOUND=yes
20817 
20818   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20819 
20820   # Input might be given as Windows format, start by converting to
20821   # unix format.
20822   path="$BOOT_JDK"
20823   new_path=`$CYGPATH -u "$path"`
20824 
20825   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20826   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20827   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20828   # "foo.exe" is OK but "foo" is an error.
20829   #
20830   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20831   # It is also a way to make sure we got the proper file name for the real test later on.
20832   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20833   if test "x$test_shortpath" = x; then
20834     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20835 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20836     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20837   fi
20838 
20839   # Call helper function which possibly converts this using DOS-style short mode.
20840   # If so, the updated path is stored in $new_path.
20841 
20842   input_path="$new_path"
20843   # Check if we need to convert this using DOS-style short mode. If the path
20844   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20845   # take no chances and rewrite it.
20846   # Note: m4 eats our [], so we need to use [ and ] instead.
20847   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20848   if test "x$has_forbidden_chars" != x; then
20849     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20850     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20851     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20852     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20853       # Going to short mode and back again did indeed matter. Since short mode is
20854       # case insensitive, let's make it lowercase to improve readability.
20855       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20856       # Now convert it back to Unix-stile (cygpath)
20857       input_path=`$CYGPATH -u "$shortmode_path"`
20858       new_path="$input_path"
20859     fi
20860   fi
20861 
20862   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20863   if test "x$test_cygdrive_prefix" = x; then
20864     # As a simple fix, exclude /usr/bin since it's not a real path.
20865     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20866       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20867       # a path prefixed by /cygdrive for fixpath to work.
20868       new_path="$CYGWIN_ROOT_PATH$input_path"
20869     fi
20870   fi
20871 
20872 
20873   if test "x$path" != "x$new_path"; then
20874     BOOT_JDK="$new_path"
20875     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20876 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20877   fi
20878 
20879   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20880 
20881   path="$BOOT_JDK"
20882   has_colon=`$ECHO $path | $GREP ^.:`
20883   new_path="$path"
20884   if test "x$has_colon" = x; then
20885     # Not in mixed or Windows style, start by that.
20886     new_path=`cmd //c echo $path`
20887   fi
20888 
20889 
20890   input_path="$new_path"
20891   # Check if we need to convert this using DOS-style short mode. If the path
20892   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20893   # take no chances and rewrite it.
20894   # Note: m4 eats our [], so we need to use [ and ] instead.
20895   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20896   if test "x$has_forbidden_chars" != x; then
20897     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20898     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20899   fi
20900 
20901 
20902   windows_path="$new_path"
20903   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20904     unix_path=`$CYGPATH -u "$windows_path"`
20905     new_path="$unix_path"
20906   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20907     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20908     new_path="$unix_path"
20909   fi
20910 
20911   if test "x$path" != "x$new_path"; then
20912     BOOT_JDK="$new_path"
20913     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20914 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20915   fi
20916 
20917   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20918   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20919 
20920   else
20921     # We're on a posix platform. Hooray! :)
20922     path="$BOOT_JDK"
20923     has_space=`$ECHO "$path" | $GREP " "`
20924     if test "x$has_space" != x; then
20925       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20926 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20927       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20928     fi
20929 
20930     # Use eval to expand a potential ~
20931     eval path="$path"
20932     if test ! -f "$path" && test ! -d "$path"; then
20933       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20934     fi
20935 
20936     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20937   fi
20938 
20939               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20940 $as_echo_n "checking for Boot JDK... " >&6; }
20941               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20942 $as_echo "$BOOT_JDK" >&6; }
20943               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20944 $as_echo_n "checking Boot JDK version... " >&6; }
20945               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20946               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20947 $as_echo "$BOOT_JDK_VERSION" >&6; }
20948             fi # end check jdk version
20949           fi # end check rt.jar
20950         fi # end check javac
20951       fi # end check java
20952     fi # end check boot jdk found
20953   fi
20954 
20955 
20956   # Test: Is $JAVA_HOME set?
20957 
20958   if test "x$BOOT_JDK_FOUND" = xno; then
20959     # Now execute the test
20960 
20961   if test "x$JAVA_HOME" != x; then
20962     JAVA_HOME_PROCESSED="$JAVA_HOME"
20963 
20964   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20965 
20966   # Input might be given as Windows format, start by converting to
20967   # unix format.
20968   path="$JAVA_HOME_PROCESSED"
20969   new_path=`$CYGPATH -u "$path"`
20970 
20971   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20972   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20973   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20974   # "foo.exe" is OK but "foo" is an error.
20975   #
20976   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20977   # It is also a way to make sure we got the proper file name for the real test later on.
20978   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20979   if test "x$test_shortpath" = x; then
20980     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
20981 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
20982     as_fn_error $? "Cannot locate the the path of JAVA_HOME_PROCESSED" "$LINENO" 5
20983   fi
20984 
20985   # Call helper function which possibly converts this using DOS-style short mode.
20986   # If so, the updated path is stored in $new_path.
20987 
20988   input_path="$new_path"
20989   # Check if we need to convert this using DOS-style short mode. If the path
20990   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20991   # take no chances and rewrite it.
20992   # Note: m4 eats our [], so we need to use [ and ] instead.
20993   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20994   if test "x$has_forbidden_chars" != x; then
20995     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20996     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20997     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20998     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20999       # Going to short mode and back again did indeed matter. Since short mode is
21000       # case insensitive, let's make it lowercase to improve readability.
21001       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21002       # Now convert it back to Unix-stile (cygpath)
21003       input_path=`$CYGPATH -u "$shortmode_path"`
21004       new_path="$input_path"
21005     fi
21006   fi
21007 
21008   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21009   if test "x$test_cygdrive_prefix" = x; then
21010     # As a simple fix, exclude /usr/bin since it's not a real path.
21011     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21012       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21013       # a path prefixed by /cygdrive for fixpath to work.
21014       new_path="$CYGWIN_ROOT_PATH$input_path"
21015     fi
21016   fi
21017 
21018 
21019   if test "x$path" != "x$new_path"; then
21020     JAVA_HOME_PROCESSED="$new_path"
21021     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
21022 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
21023   fi
21024 
21025   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21026 
21027   path="$JAVA_HOME_PROCESSED"
21028   has_colon=`$ECHO $path | $GREP ^.:`
21029   new_path="$path"
21030   if test "x$has_colon" = x; then
21031     # Not in mixed or Windows style, start by that.
21032     new_path=`cmd //c echo $path`
21033   fi
21034 
21035 
21036   input_path="$new_path"
21037   # Check if we need to convert this using DOS-style short mode. If the path
21038   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21039   # take no chances and rewrite it.
21040   # Note: m4 eats our [], so we need to use [ and ] instead.
21041   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21042   if test "x$has_forbidden_chars" != x; then
21043     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21044     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21045   fi
21046 
21047 
21048   windows_path="$new_path"
21049   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21050     unix_path=`$CYGPATH -u "$windows_path"`
21051     new_path="$unix_path"
21052   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21053     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21054     new_path="$unix_path"
21055   fi
21056 
21057   if test "x$path" != "x$new_path"; then
21058     JAVA_HOME_PROCESSED="$new_path"
21059     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
21060 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
21061   fi
21062 
21063   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21064   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21065 
21066   else
21067     # We're on a posix platform. Hooray! :)
21068     path="$JAVA_HOME_PROCESSED"
21069     has_space=`$ECHO "$path" | $GREP " "`
21070     if test "x$has_space" != x; then
21071       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
21072 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
21073       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21074     fi
21075 
21076     # Use eval to expand a potential ~
21077     eval path="$path"
21078     if test ! -f "$path" && test ! -d "$path"; then
21079       as_fn_error $? "The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is not found." "$LINENO" 5
21080     fi
21081 
21082     JAVA_HOME_PROCESSED="`cd "$path"; $THEPWDCMD -L`"
21083   fi
21084 
21085     if test ! -d "$JAVA_HOME_PROCESSED"; then
21086       { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
21087 $as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
21088     else
21089       # Aha, the user has set a JAVA_HOME
21090       # let us use that as the Boot JDK.
21091       BOOT_JDK="$JAVA_HOME_PROCESSED"
21092       BOOT_JDK_FOUND=maybe
21093       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using JAVA_HOME" >&5
21094 $as_echo "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
21095     fi
21096   fi
21097 
21098 
21099     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21100     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21101       # Do we have a bin/java?
21102       if test ! -x "$BOOT_JDK/bin/java"; then
21103         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21104 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21105         BOOT_JDK_FOUND=no
21106       else
21107         # Do we have a bin/javac?
21108         if test ! -x "$BOOT_JDK/bin/javac"; then
21109           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21110 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21111           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21112 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21113           BOOT_JDK_FOUND=no
21114         else
21115           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
21116           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
21117             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
21118 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
21119             BOOT_JDK_FOUND=no
21120           else
21121             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21122             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21123 
21124             # Extra M4 quote needed to protect [] in grep expression.
21125             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
21126             if test "x$FOUND_CORRECT_VERSION" = x; then
21127               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21128 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21129               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
21130 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
21131               BOOT_JDK_FOUND=no
21132             else
21133               # We're done! :-)
21134               BOOT_JDK_FOUND=yes
21135 
21136   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21137 
21138   # Input might be given as Windows format, start by converting to
21139   # unix format.
21140   path="$BOOT_JDK"
21141   new_path=`$CYGPATH -u "$path"`
21142 
21143   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21144   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21145   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21146   # "foo.exe" is OK but "foo" is an error.
21147   #
21148   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21149   # It is also a way to make sure we got the proper file name for the real test later on.
21150   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21151   if test "x$test_shortpath" = x; then
21152     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21153 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21154     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21155   fi
21156 
21157   # Call helper function which possibly converts this using DOS-style short mode.
21158   # If so, the updated path is stored in $new_path.
21159 
21160   input_path="$new_path"
21161   # Check if we need to convert this using DOS-style short mode. If the path
21162   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21163   # take no chances and rewrite it.
21164   # Note: m4 eats our [], so we need to use [ and ] instead.
21165   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21166   if test "x$has_forbidden_chars" != x; then
21167     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21168     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21169     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21170     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21171       # Going to short mode and back again did indeed matter. Since short mode is
21172       # case insensitive, let's make it lowercase to improve readability.
21173       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21174       # Now convert it back to Unix-stile (cygpath)
21175       input_path=`$CYGPATH -u "$shortmode_path"`
21176       new_path="$input_path"
21177     fi
21178   fi
21179 
21180   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21181   if test "x$test_cygdrive_prefix" = x; then
21182     # As a simple fix, exclude /usr/bin since it's not a real path.
21183     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21184       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21185       # a path prefixed by /cygdrive for fixpath to work.
21186       new_path="$CYGWIN_ROOT_PATH$input_path"
21187     fi
21188   fi
21189 
21190 
21191   if test "x$path" != "x$new_path"; then
21192     BOOT_JDK="$new_path"
21193     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21194 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21195   fi
21196 
21197   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21198 
21199   path="$BOOT_JDK"
21200   has_colon=`$ECHO $path | $GREP ^.:`
21201   new_path="$path"
21202   if test "x$has_colon" = x; then
21203     # Not in mixed or Windows style, start by that.
21204     new_path=`cmd //c echo $path`
21205   fi
21206 
21207 
21208   input_path="$new_path"
21209   # Check if we need to convert this using DOS-style short mode. If the path
21210   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21211   # take no chances and rewrite it.
21212   # Note: m4 eats our [], so we need to use [ and ] instead.
21213   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21214   if test "x$has_forbidden_chars" != x; then
21215     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21216     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21217   fi
21218 
21219 
21220   windows_path="$new_path"
21221   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21222     unix_path=`$CYGPATH -u "$windows_path"`
21223     new_path="$unix_path"
21224   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21225     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21226     new_path="$unix_path"
21227   fi
21228 
21229   if test "x$path" != "x$new_path"; then
21230     BOOT_JDK="$new_path"
21231     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21232 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21233   fi
21234 
21235   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21236   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21237 
21238   else
21239     # We're on a posix platform. Hooray! :)
21240     path="$BOOT_JDK"
21241     has_space=`$ECHO "$path" | $GREP " "`
21242     if test "x$has_space" != x; then
21243       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21244 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21245       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21246     fi
21247 
21248     # Use eval to expand a potential ~
21249     eval path="$path"
21250     if test ! -f "$path" && test ! -d "$path"; then
21251       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21252     fi
21253 
21254     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21255   fi
21256 
21257               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21258 $as_echo_n "checking for Boot JDK... " >&6; }
21259               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21260 $as_echo "$BOOT_JDK" >&6; }
21261               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21262 $as_echo_n "checking Boot JDK version... " >&6; }
21263               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21264               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21265 $as_echo "$BOOT_JDK_VERSION" >&6; }
21266             fi # end check jdk version
21267           fi # end check rt.jar
21268         fi # end check javac
21269       fi # end check java
21270     fi # end check boot jdk found
21271   fi
21272 
21273 
21274   # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
21275 
21276   if test "x$BOOT_JDK_FOUND" = xno; then
21277     # Now execute the test
21278 
21279   # Extract the first word of "javac", so it can be a program name with args.
21280 set dummy javac; ac_word=$2
21281 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21282 $as_echo_n "checking for $ac_word... " >&6; }
21283 if ${ac_cv_path_JAVAC_CHECK+:} false; then :
21284   $as_echo_n "(cached) " >&6
21285 else
21286   case $JAVAC_CHECK in
21287   [\\/]* | ?:[\\/]*)
21288   ac_cv_path_JAVAC_CHECK="$JAVAC_CHECK" # Let the user override the test with a path.
21289   ;;
21290   *)
21291   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21292 for as_dir in $PATH
21293 do
21294   IFS=$as_save_IFS
21295   test -z "$as_dir" && as_dir=.
21296     for ac_exec_ext in '' $ac_executable_extensions; do
21297   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21298     ac_cv_path_JAVAC_CHECK="$as_dir/$ac_word$ac_exec_ext"
21299     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21300     break 2
21301   fi
21302 done
21303   done
21304 IFS=$as_save_IFS
21305 
21306   ;;
21307 esac
21308 fi
21309 JAVAC_CHECK=$ac_cv_path_JAVAC_CHECK
21310 if test -n "$JAVAC_CHECK"; then
21311   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5
21312 $as_echo "$JAVAC_CHECK" >&6; }
21313 else
21314   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21315 $as_echo "no" >&6; }
21316 fi
21317 
21318 
21319   # Extract the first word of "java", so it can be a program name with args.
21320 set dummy java; ac_word=$2
21321 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21322 $as_echo_n "checking for $ac_word... " >&6; }
21323 if ${ac_cv_path_JAVA_CHECK+:} false; then :
21324   $as_echo_n "(cached) " >&6
21325 else
21326   case $JAVA_CHECK in
21327   [\\/]* | ?:[\\/]*)
21328   ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path.
21329   ;;
21330   *)
21331   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21332 for as_dir in $PATH
21333 do
21334   IFS=$as_save_IFS
21335   test -z "$as_dir" && as_dir=.
21336     for ac_exec_ext in '' $ac_executable_extensions; do
21337   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21338     ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext"
21339     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21340     break 2
21341   fi
21342 done
21343   done
21344 IFS=$as_save_IFS
21345 
21346   ;;
21347 esac
21348 fi
21349 JAVA_CHECK=$ac_cv_path_JAVA_CHECK
21350 if test -n "$JAVA_CHECK"; then
21351   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5
21352 $as_echo "$JAVA_CHECK" >&6; }
21353 else
21354   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21355 $as_echo "no" >&6; }
21356 fi
21357 
21358 
21359   BINARY="$JAVAC_CHECK"
21360   if test "x$JAVAC_CHECK" = x; then
21361     BINARY="$JAVA_CHECK"
21362   fi
21363   if test "x$BINARY" != x; then
21364     # So there is a java(c) binary, it might be part of a JDK.
21365     # Lets find the JDK/JRE directory by following symbolic links.
21366     # Linux/GNU systems often have links from /usr/bin/java to
21367     # /etc/alternatives/java to the real JDK binary.
21368 
21369   if test "x$OPENJDK_BUILD_OS" != xwindows; then
21370     # Follow a chain of symbolic links. Use readlink
21371     # where it exists, else fall back to horribly
21372     # complicated shell code.
21373     if test "x$READLINK_TESTED" != yes; then
21374       # On MacOSX there is a readlink tool with a different
21375       # purpose than the GNU readlink tool. Check the found readlink.
21376       ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
21377       if test "x$ISGNU" = x; then
21378         # A readlink that we do not know how to use.
21379         # Are there other non-GNU readlinks out there?
21380         READLINK_TESTED=yes
21381         READLINK=
21382       fi
21383     fi
21384 
21385     if test "x$READLINK" != x; then
21386       BINARY=`$READLINK -f $BINARY`
21387     else
21388       # Save the current directory for restoring afterwards
21389       STARTDIR=$PWD
21390       COUNTER=0
21391       sym_link_dir=`$DIRNAME $BINARY`
21392       sym_link_file=`$BASENAME $BINARY`
21393       cd $sym_link_dir
21394       # Use -P flag to resolve symlinks in directories.
21395       cd `$THEPWDCMD -P`
21396       sym_link_dir=`$THEPWDCMD -P`
21397       # Resolve file symlinks
21398       while test $COUNTER -lt 20; do
21399         ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
21400         if test "x$ISLINK" == x; then
21401           # This is not a symbolic link! We are done!
21402           break
21403         fi
21404         # Again resolve directory symlinks since the target of the just found
21405         # link could be in a different directory
21406         cd `$DIRNAME $ISLINK`
21407         sym_link_dir=`$THEPWDCMD -P`
21408         sym_link_file=`$BASENAME $ISLINK`
21409         let COUNTER=COUNTER+1
21410       done
21411       cd $STARTDIR
21412       BINARY=$sym_link_dir/$sym_link_file
21413     fi
21414   fi
21415 
21416     BOOT_JDK=`dirname "$BINARY"`
21417     BOOT_JDK=`cd "$BOOT_JDK/.."; pwd`
21418     if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then
21419       # Looks like we found ourselves an JDK
21420       BOOT_JDK_FOUND=maybe
21421       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using java(c) in PATH" >&5
21422 $as_echo "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
21423     fi
21424   fi
21425 
21426 
21427     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21428     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21429       # Do we have a bin/java?
21430       if test ! -x "$BOOT_JDK/bin/java"; then
21431         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21432 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21433         BOOT_JDK_FOUND=no
21434       else
21435         # Do we have a bin/javac?
21436         if test ! -x "$BOOT_JDK/bin/javac"; then
21437           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21438 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21439           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21440 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21441           BOOT_JDK_FOUND=no
21442         else
21443           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
21444           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
21445             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
21446 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
21447             BOOT_JDK_FOUND=no
21448           else
21449             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21450             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21451 
21452             # Extra M4 quote needed to protect [] in grep expression.
21453             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
21454             if test "x$FOUND_CORRECT_VERSION" = x; then
21455               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21456 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21457               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
21458 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
21459               BOOT_JDK_FOUND=no
21460             else
21461               # We're done! :-)
21462               BOOT_JDK_FOUND=yes
21463 
21464   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21465 
21466   # Input might be given as Windows format, start by converting to
21467   # unix format.
21468   path="$BOOT_JDK"
21469   new_path=`$CYGPATH -u "$path"`
21470 
21471   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21472   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21473   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21474   # "foo.exe" is OK but "foo" is an error.
21475   #
21476   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21477   # It is also a way to make sure we got the proper file name for the real test later on.
21478   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21479   if test "x$test_shortpath" = x; then
21480     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21481 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21482     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21483   fi
21484 
21485   # Call helper function which possibly converts this using DOS-style short mode.
21486   # If so, the updated path is stored in $new_path.
21487 
21488   input_path="$new_path"
21489   # Check if we need to convert this using DOS-style short mode. If the path
21490   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21491   # take no chances and rewrite it.
21492   # Note: m4 eats our [], so we need to use [ and ] instead.
21493   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21494   if test "x$has_forbidden_chars" != x; then
21495     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21496     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21497     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21498     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21499       # Going to short mode and back again did indeed matter. Since short mode is
21500       # case insensitive, let's make it lowercase to improve readability.
21501       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21502       # Now convert it back to Unix-stile (cygpath)
21503       input_path=`$CYGPATH -u "$shortmode_path"`
21504       new_path="$input_path"
21505     fi
21506   fi
21507 
21508   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21509   if test "x$test_cygdrive_prefix" = x; then
21510     # As a simple fix, exclude /usr/bin since it's not a real path.
21511     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21512       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21513       # a path prefixed by /cygdrive for fixpath to work.
21514       new_path="$CYGWIN_ROOT_PATH$input_path"
21515     fi
21516   fi
21517 
21518 
21519   if test "x$path" != "x$new_path"; then
21520     BOOT_JDK="$new_path"
21521     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21522 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21523   fi
21524 
21525   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21526 
21527   path="$BOOT_JDK"
21528   has_colon=`$ECHO $path | $GREP ^.:`
21529   new_path="$path"
21530   if test "x$has_colon" = x; then
21531     # Not in mixed or Windows style, start by that.
21532     new_path=`cmd //c echo $path`
21533   fi
21534 
21535 
21536   input_path="$new_path"
21537   # Check if we need to convert this using DOS-style short mode. If the path
21538   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21539   # take no chances and rewrite it.
21540   # Note: m4 eats our [], so we need to use [ and ] instead.
21541   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21542   if test "x$has_forbidden_chars" != x; then
21543     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21544     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21545   fi
21546 
21547 
21548   windows_path="$new_path"
21549   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21550     unix_path=`$CYGPATH -u "$windows_path"`
21551     new_path="$unix_path"
21552   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21553     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21554     new_path="$unix_path"
21555   fi
21556 
21557   if test "x$path" != "x$new_path"; then
21558     BOOT_JDK="$new_path"
21559     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21560 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21561   fi
21562 
21563   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21564   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21565 
21566   else
21567     # We're on a posix platform. Hooray! :)
21568     path="$BOOT_JDK"
21569     has_space=`$ECHO "$path" | $GREP " "`
21570     if test "x$has_space" != x; then
21571       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21572 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21573       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21574     fi
21575 
21576     # Use eval to expand a potential ~
21577     eval path="$path"
21578     if test ! -f "$path" && test ! -d "$path"; then
21579       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21580     fi
21581 
21582     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21583   fi
21584 
21585               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21586 $as_echo_n "checking for Boot JDK... " >&6; }
21587               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21588 $as_echo "$BOOT_JDK" >&6; }
21589               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21590 $as_echo_n "checking Boot JDK version... " >&6; }
21591               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21592               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21593 $as_echo "$BOOT_JDK_VERSION" >&6; }
21594             fi # end check jdk version
21595           fi # end check rt.jar
21596         fi # end check javac
21597       fi # end check java
21598     fi # end check boot jdk found
21599   fi
21600 
21601 
21602   # Test: Is there a JDK installed in default, well-known locations?
21603 
21604   if test "x$BOOT_JDK_FOUND" = xno; then
21605     # Now execute the test
21606 
21607   if test "x$OPENJDK_TARGET_OS" = xwindows; then
21608 
21609   if test "x$BOOT_JDK_FOUND" = xno; then
21610     # Now execute the test
21611 
21612   if test "x$ProgramW6432" != x; then
21613     VIRTUAL_DIR="$ProgramW6432/Java"
21614 
21615   windows_path="$VIRTUAL_DIR"
21616   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21617     unix_path=`$CYGPATH -u "$windows_path"`
21618     VIRTUAL_DIR="$unix_path"
21619   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21620     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21621     VIRTUAL_DIR="$unix_path"
21622   fi
21623 
21624 
21625   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
21626   BOOT_JDK_SUFFIX=""
21627   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
21628   if test "x$ALL_JDKS_FOUND" != x; then
21629     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
21630 
21631   if test "x$BOOT_JDK_FOUND" = xno; then
21632     # Now execute the test
21633 
21634         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
21635         if test -d "$BOOT_JDK"; then
21636           BOOT_JDK_FOUND=maybe
21637           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
21638 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
21639         fi
21640 
21641 
21642     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21643     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21644       # Do we have a bin/java?
21645       if test ! -x "$BOOT_JDK/bin/java"; then
21646         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21647 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21648         BOOT_JDK_FOUND=no
21649       else
21650         # Do we have a bin/javac?
21651         if test ! -x "$BOOT_JDK/bin/javac"; then
21652           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21653 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21654           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21655 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21656           BOOT_JDK_FOUND=no
21657         else
21658           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
21659           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
21660             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
21661 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
21662             BOOT_JDK_FOUND=no
21663           else
21664             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21665             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21666 
21667             # Extra M4 quote needed to protect [] in grep expression.
21668             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
21669             if test "x$FOUND_CORRECT_VERSION" = x; then
21670               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21671 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21672               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
21673 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
21674               BOOT_JDK_FOUND=no
21675             else
21676               # We're done! :-)
21677               BOOT_JDK_FOUND=yes
21678 
21679   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21680 
21681   # Input might be given as Windows format, start by converting to
21682   # unix format.
21683   path="$BOOT_JDK"
21684   new_path=`$CYGPATH -u "$path"`
21685 
21686   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21687   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21688   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21689   # "foo.exe" is OK but "foo" is an error.
21690   #
21691   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21692   # It is also a way to make sure we got the proper file name for the real test later on.
21693   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21694   if test "x$test_shortpath" = x; then
21695     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21696 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21697     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21698   fi
21699 
21700   # Call helper function which possibly converts this using DOS-style short mode.
21701   # If so, the updated path is stored in $new_path.
21702 
21703   input_path="$new_path"
21704   # Check if we need to convert this using DOS-style short mode. If the path
21705   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21706   # take no chances and rewrite it.
21707   # Note: m4 eats our [], so we need to use [ and ] instead.
21708   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21709   if test "x$has_forbidden_chars" != x; then
21710     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21711     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21712     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21713     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21714       # Going to short mode and back again did indeed matter. Since short mode is
21715       # case insensitive, let's make it lowercase to improve readability.
21716       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21717       # Now convert it back to Unix-stile (cygpath)
21718       input_path=`$CYGPATH -u "$shortmode_path"`
21719       new_path="$input_path"
21720     fi
21721   fi
21722 
21723   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21724   if test "x$test_cygdrive_prefix" = x; then
21725     # As a simple fix, exclude /usr/bin since it's not a real path.
21726     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21727       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21728       # a path prefixed by /cygdrive for fixpath to work.
21729       new_path="$CYGWIN_ROOT_PATH$input_path"
21730     fi
21731   fi
21732 
21733 
21734   if test "x$path" != "x$new_path"; then
21735     BOOT_JDK="$new_path"
21736     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21737 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21738   fi
21739 
21740   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21741 
21742   path="$BOOT_JDK"
21743   has_colon=`$ECHO $path | $GREP ^.:`
21744   new_path="$path"
21745   if test "x$has_colon" = x; then
21746     # Not in mixed or Windows style, start by that.
21747     new_path=`cmd //c echo $path`
21748   fi
21749 
21750 
21751   input_path="$new_path"
21752   # Check if we need to convert this using DOS-style short mode. If the path
21753   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21754   # take no chances and rewrite it.
21755   # Note: m4 eats our [], so we need to use [ and ] instead.
21756   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21757   if test "x$has_forbidden_chars" != x; then
21758     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21759     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21760   fi
21761 
21762 
21763   windows_path="$new_path"
21764   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21765     unix_path=`$CYGPATH -u "$windows_path"`
21766     new_path="$unix_path"
21767   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21768     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21769     new_path="$unix_path"
21770   fi
21771 
21772   if test "x$path" != "x$new_path"; then
21773     BOOT_JDK="$new_path"
21774     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21775 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21776   fi
21777 
21778   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21779   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21780 
21781   else
21782     # We're on a posix platform. Hooray! :)
21783     path="$BOOT_JDK"
21784     has_space=`$ECHO "$path" | $GREP " "`
21785     if test "x$has_space" != x; then
21786       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21787 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21788       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21789     fi
21790 
21791     # Use eval to expand a potential ~
21792     eval path="$path"
21793     if test ! -f "$path" && test ! -d "$path"; then
21794       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21795     fi
21796 
21797     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21798   fi
21799 
21800               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21801 $as_echo_n "checking for Boot JDK... " >&6; }
21802               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21803 $as_echo "$BOOT_JDK" >&6; }
21804               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21805 $as_echo_n "checking Boot JDK version... " >&6; }
21806               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21807               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21808 $as_echo "$BOOT_JDK_VERSION" >&6; }
21809             fi # end check jdk version
21810           fi # end check rt.jar
21811         fi # end check javac
21812       fi # end check java
21813     fi # end check boot jdk found
21814   fi
21815 
21816     done
21817   fi
21818 
21819   fi
21820 
21821 
21822     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21823     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21824       # Do we have a bin/java?
21825       if test ! -x "$BOOT_JDK/bin/java"; then
21826         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21827 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21828         BOOT_JDK_FOUND=no
21829       else
21830         # Do we have a bin/javac?
21831         if test ! -x "$BOOT_JDK/bin/javac"; then
21832           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21833 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21834           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21835 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21836           BOOT_JDK_FOUND=no
21837         else
21838           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
21839           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
21840             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
21841 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
21842             BOOT_JDK_FOUND=no
21843           else
21844             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21845             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21846 
21847             # Extra M4 quote needed to protect [] in grep expression.
21848             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
21849             if test "x$FOUND_CORRECT_VERSION" = x; then
21850               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21851 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21852               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
21853 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
21854               BOOT_JDK_FOUND=no
21855             else
21856               # We're done! :-)
21857               BOOT_JDK_FOUND=yes
21858 
21859   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21860 
21861   # Input might be given as Windows format, start by converting to
21862   # unix format.
21863   path="$BOOT_JDK"
21864   new_path=`$CYGPATH -u "$path"`
21865 
21866   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21867   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21868   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21869   # "foo.exe" is OK but "foo" is an error.
21870   #
21871   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21872   # It is also a way to make sure we got the proper file name for the real test later on.
21873   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21874   if test "x$test_shortpath" = x; then
21875     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21876 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21877     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21878   fi
21879 
21880   # Call helper function which possibly converts this using DOS-style short mode.
21881   # If so, the updated path is stored in $new_path.
21882 
21883   input_path="$new_path"
21884   # Check if we need to convert this using DOS-style short mode. If the path
21885   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21886   # take no chances and rewrite it.
21887   # Note: m4 eats our [], so we need to use [ and ] instead.
21888   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21889   if test "x$has_forbidden_chars" != x; then
21890     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21891     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21892     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21893     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21894       # Going to short mode and back again did indeed matter. Since short mode is
21895       # case insensitive, let's make it lowercase to improve readability.
21896       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21897       # Now convert it back to Unix-stile (cygpath)
21898       input_path=`$CYGPATH -u "$shortmode_path"`
21899       new_path="$input_path"
21900     fi
21901   fi
21902 
21903   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21904   if test "x$test_cygdrive_prefix" = x; then
21905     # As a simple fix, exclude /usr/bin since it's not a real path.
21906     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21907       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21908       # a path prefixed by /cygdrive for fixpath to work.
21909       new_path="$CYGWIN_ROOT_PATH$input_path"
21910     fi
21911   fi
21912 
21913 
21914   if test "x$path" != "x$new_path"; then
21915     BOOT_JDK="$new_path"
21916     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21917 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21918   fi
21919 
21920   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21921 
21922   path="$BOOT_JDK"
21923   has_colon=`$ECHO $path | $GREP ^.:`
21924   new_path="$path"
21925   if test "x$has_colon" = x; then
21926     # Not in mixed or Windows style, start by that.
21927     new_path=`cmd //c echo $path`
21928   fi
21929 
21930 
21931   input_path="$new_path"
21932   # Check if we need to convert this using DOS-style short mode. If the path
21933   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21934   # take no chances and rewrite it.
21935   # Note: m4 eats our [], so we need to use [ and ] instead.
21936   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21937   if test "x$has_forbidden_chars" != x; then
21938     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21939     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21940   fi
21941 
21942 
21943   windows_path="$new_path"
21944   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21945     unix_path=`$CYGPATH -u "$windows_path"`
21946     new_path="$unix_path"
21947   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21948     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21949     new_path="$unix_path"
21950   fi
21951 
21952   if test "x$path" != "x$new_path"; then
21953     BOOT_JDK="$new_path"
21954     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21955 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21956   fi
21957 
21958   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21959   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21960 
21961   else
21962     # We're on a posix platform. Hooray! :)
21963     path="$BOOT_JDK"
21964     has_space=`$ECHO "$path" | $GREP " "`
21965     if test "x$has_space" != x; then
21966       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21967 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21968       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21969     fi
21970 
21971     # Use eval to expand a potential ~
21972     eval path="$path"
21973     if test ! -f "$path" && test ! -d "$path"; then
21974       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21975     fi
21976 
21977     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21978   fi
21979 
21980               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21981 $as_echo_n "checking for Boot JDK... " >&6; }
21982               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21983 $as_echo "$BOOT_JDK" >&6; }
21984               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21985 $as_echo_n "checking Boot JDK version... " >&6; }
21986               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21987               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21988 $as_echo "$BOOT_JDK_VERSION" >&6; }
21989             fi # end check jdk version
21990           fi # end check rt.jar
21991         fi # end check javac
21992       fi # end check java
21993     fi # end check boot jdk found
21994   fi
21995 
21996 
21997   if test "x$BOOT_JDK_FOUND" = xno; then
21998     # Now execute the test
21999 
22000   if test "x$PROGRAMW6432" != x; then
22001     VIRTUAL_DIR="$PROGRAMW6432/Java"
22002 
22003   windows_path="$VIRTUAL_DIR"
22004   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22005     unix_path=`$CYGPATH -u "$windows_path"`
22006     VIRTUAL_DIR="$unix_path"
22007   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22008     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22009     VIRTUAL_DIR="$unix_path"
22010   fi
22011 
22012 
22013   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22014   BOOT_JDK_SUFFIX=""
22015   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22016   if test "x$ALL_JDKS_FOUND" != x; then
22017     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22018 
22019   if test "x$BOOT_JDK_FOUND" = xno; then
22020     # Now execute the test
22021 
22022         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22023         if test -d "$BOOT_JDK"; then
22024           BOOT_JDK_FOUND=maybe
22025           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22026 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22027         fi
22028 
22029 
22030     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22031     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22032       # Do we have a bin/java?
22033       if test ! -x "$BOOT_JDK/bin/java"; then
22034         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22035 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22036         BOOT_JDK_FOUND=no
22037       else
22038         # Do we have a bin/javac?
22039         if test ! -x "$BOOT_JDK/bin/javac"; then
22040           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22041 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22042           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22043 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22044           BOOT_JDK_FOUND=no
22045         else
22046           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22047           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22048             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22049 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22050             BOOT_JDK_FOUND=no
22051           else
22052             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22053             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22054 
22055             # Extra M4 quote needed to protect [] in grep expression.
22056             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
22057             if test "x$FOUND_CORRECT_VERSION" = x; then
22058               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22059 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22060               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
22061 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
22062               BOOT_JDK_FOUND=no
22063             else
22064               # We're done! :-)
22065               BOOT_JDK_FOUND=yes
22066 
22067   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22068 
22069   # Input might be given as Windows format, start by converting to
22070   # unix format.
22071   path="$BOOT_JDK"
22072   new_path=`$CYGPATH -u "$path"`
22073 
22074   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22075   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22076   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22077   # "foo.exe" is OK but "foo" is an error.
22078   #
22079   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22080   # It is also a way to make sure we got the proper file name for the real test later on.
22081   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22082   if test "x$test_shortpath" = x; then
22083     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22084 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22085     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22086   fi
22087 
22088   # Call helper function which possibly converts this using DOS-style short mode.
22089   # If so, the updated path is stored in $new_path.
22090 
22091   input_path="$new_path"
22092   # Check if we need to convert this using DOS-style short mode. If the path
22093   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22094   # take no chances and rewrite it.
22095   # Note: m4 eats our [], so we need to use [ and ] instead.
22096   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22097   if test "x$has_forbidden_chars" != x; then
22098     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22099     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22100     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22101     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22102       # Going to short mode and back again did indeed matter. Since short mode is
22103       # case insensitive, let's make it lowercase to improve readability.
22104       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22105       # Now convert it back to Unix-stile (cygpath)
22106       input_path=`$CYGPATH -u "$shortmode_path"`
22107       new_path="$input_path"
22108     fi
22109   fi
22110 
22111   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22112   if test "x$test_cygdrive_prefix" = x; then
22113     # As a simple fix, exclude /usr/bin since it's not a real path.
22114     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22115       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22116       # a path prefixed by /cygdrive for fixpath to work.
22117       new_path="$CYGWIN_ROOT_PATH$input_path"
22118     fi
22119   fi
22120 
22121 
22122   if test "x$path" != "x$new_path"; then
22123     BOOT_JDK="$new_path"
22124     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22125 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22126   fi
22127 
22128   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22129 
22130   path="$BOOT_JDK"
22131   has_colon=`$ECHO $path | $GREP ^.:`
22132   new_path="$path"
22133   if test "x$has_colon" = x; then
22134     # Not in mixed or Windows style, start by that.
22135     new_path=`cmd //c echo $path`
22136   fi
22137 
22138 
22139   input_path="$new_path"
22140   # Check if we need to convert this using DOS-style short mode. If the path
22141   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22142   # take no chances and rewrite it.
22143   # Note: m4 eats our [], so we need to use [ and ] instead.
22144   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22145   if test "x$has_forbidden_chars" != x; then
22146     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22147     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22148   fi
22149 
22150 
22151   windows_path="$new_path"
22152   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22153     unix_path=`$CYGPATH -u "$windows_path"`
22154     new_path="$unix_path"
22155   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22156     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22157     new_path="$unix_path"
22158   fi
22159 
22160   if test "x$path" != "x$new_path"; then
22161     BOOT_JDK="$new_path"
22162     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22163 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22164   fi
22165 
22166   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22167   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22168 
22169   else
22170     # We're on a posix platform. Hooray! :)
22171     path="$BOOT_JDK"
22172     has_space=`$ECHO "$path" | $GREP " "`
22173     if test "x$has_space" != x; then
22174       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22175 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22176       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22177     fi
22178 
22179     # Use eval to expand a potential ~
22180     eval path="$path"
22181     if test ! -f "$path" && test ! -d "$path"; then
22182       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22183     fi
22184 
22185     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22186   fi
22187 
22188               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22189 $as_echo_n "checking for Boot JDK... " >&6; }
22190               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22191 $as_echo "$BOOT_JDK" >&6; }
22192               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22193 $as_echo_n "checking Boot JDK version... " >&6; }
22194               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22195               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22196 $as_echo "$BOOT_JDK_VERSION" >&6; }
22197             fi # end check jdk version
22198           fi # end check rt.jar
22199         fi # end check javac
22200       fi # end check java
22201     fi # end check boot jdk found
22202   fi
22203 
22204     done
22205   fi
22206 
22207   fi
22208 
22209 
22210     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22211     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22212       # Do we have a bin/java?
22213       if test ! -x "$BOOT_JDK/bin/java"; then
22214         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22215 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22216         BOOT_JDK_FOUND=no
22217       else
22218         # Do we have a bin/javac?
22219         if test ! -x "$BOOT_JDK/bin/javac"; then
22220           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22221 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22222           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22223 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22224           BOOT_JDK_FOUND=no
22225         else
22226           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22227           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22228             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22229 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22230             BOOT_JDK_FOUND=no
22231           else
22232             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22233             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22234 
22235             # Extra M4 quote needed to protect [] in grep expression.
22236             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
22237             if test "x$FOUND_CORRECT_VERSION" = x; then
22238               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22239 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22240               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
22241 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
22242               BOOT_JDK_FOUND=no
22243             else
22244               # We're done! :-)
22245               BOOT_JDK_FOUND=yes
22246 
22247   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22248 
22249   # Input might be given as Windows format, start by converting to
22250   # unix format.
22251   path="$BOOT_JDK"
22252   new_path=`$CYGPATH -u "$path"`
22253 
22254   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22255   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22256   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22257   # "foo.exe" is OK but "foo" is an error.
22258   #
22259   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22260   # It is also a way to make sure we got the proper file name for the real test later on.
22261   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22262   if test "x$test_shortpath" = x; then
22263     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22264 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22265     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22266   fi
22267 
22268   # Call helper function which possibly converts this using DOS-style short mode.
22269   # If so, the updated path is stored in $new_path.
22270 
22271   input_path="$new_path"
22272   # Check if we need to convert this using DOS-style short mode. If the path
22273   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22274   # take no chances and rewrite it.
22275   # Note: m4 eats our [], so we need to use [ and ] instead.
22276   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22277   if test "x$has_forbidden_chars" != x; then
22278     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22279     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22280     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22281     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22282       # Going to short mode and back again did indeed matter. Since short mode is
22283       # case insensitive, let's make it lowercase to improve readability.
22284       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22285       # Now convert it back to Unix-stile (cygpath)
22286       input_path=`$CYGPATH -u "$shortmode_path"`
22287       new_path="$input_path"
22288     fi
22289   fi
22290 
22291   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22292   if test "x$test_cygdrive_prefix" = x; then
22293     # As a simple fix, exclude /usr/bin since it's not a real path.
22294     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22295       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22296       # a path prefixed by /cygdrive for fixpath to work.
22297       new_path="$CYGWIN_ROOT_PATH$input_path"
22298     fi
22299   fi
22300 
22301 
22302   if test "x$path" != "x$new_path"; then
22303     BOOT_JDK="$new_path"
22304     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22305 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22306   fi
22307 
22308   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22309 
22310   path="$BOOT_JDK"
22311   has_colon=`$ECHO $path | $GREP ^.:`
22312   new_path="$path"
22313   if test "x$has_colon" = x; then
22314     # Not in mixed or Windows style, start by that.
22315     new_path=`cmd //c echo $path`
22316   fi
22317 
22318 
22319   input_path="$new_path"
22320   # Check if we need to convert this using DOS-style short mode. If the path
22321   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22322   # take no chances and rewrite it.
22323   # Note: m4 eats our [], so we need to use [ and ] instead.
22324   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22325   if test "x$has_forbidden_chars" != x; then
22326     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22327     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22328   fi
22329 
22330 
22331   windows_path="$new_path"
22332   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22333     unix_path=`$CYGPATH -u "$windows_path"`
22334     new_path="$unix_path"
22335   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22336     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22337     new_path="$unix_path"
22338   fi
22339 
22340   if test "x$path" != "x$new_path"; then
22341     BOOT_JDK="$new_path"
22342     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22343 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22344   fi
22345 
22346   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22347   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22348 
22349   else
22350     # We're on a posix platform. Hooray! :)
22351     path="$BOOT_JDK"
22352     has_space=`$ECHO "$path" | $GREP " "`
22353     if test "x$has_space" != x; then
22354       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22355 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22356       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22357     fi
22358 
22359     # Use eval to expand a potential ~
22360     eval path="$path"
22361     if test ! -f "$path" && test ! -d "$path"; then
22362       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22363     fi
22364 
22365     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22366   fi
22367 
22368               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22369 $as_echo_n "checking for Boot JDK... " >&6; }
22370               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22371 $as_echo "$BOOT_JDK" >&6; }
22372               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22373 $as_echo_n "checking Boot JDK version... " >&6; }
22374               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22375               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22376 $as_echo "$BOOT_JDK_VERSION" >&6; }
22377             fi # end check jdk version
22378           fi # end check rt.jar
22379         fi # end check javac
22380       fi # end check java
22381     fi # end check boot jdk found
22382   fi
22383 
22384 
22385   if test "x$BOOT_JDK_FOUND" = xno; then
22386     # Now execute the test
22387 
22388   if test "x$PROGRAMFILES" != x; then
22389     VIRTUAL_DIR="$PROGRAMFILES/Java"
22390 
22391   windows_path="$VIRTUAL_DIR"
22392   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22393     unix_path=`$CYGPATH -u "$windows_path"`
22394     VIRTUAL_DIR="$unix_path"
22395   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22396     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22397     VIRTUAL_DIR="$unix_path"
22398   fi
22399 
22400 
22401   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22402   BOOT_JDK_SUFFIX=""
22403   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22404   if test "x$ALL_JDKS_FOUND" != x; then
22405     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22406 
22407   if test "x$BOOT_JDK_FOUND" = xno; then
22408     # Now execute the test
22409 
22410         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22411         if test -d "$BOOT_JDK"; then
22412           BOOT_JDK_FOUND=maybe
22413           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22414 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22415         fi
22416 
22417 
22418     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22419     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22420       # Do we have a bin/java?
22421       if test ! -x "$BOOT_JDK/bin/java"; then
22422         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22423 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22424         BOOT_JDK_FOUND=no
22425       else
22426         # Do we have a bin/javac?
22427         if test ! -x "$BOOT_JDK/bin/javac"; then
22428           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22429 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22430           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22431 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22432           BOOT_JDK_FOUND=no
22433         else
22434           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22435           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22436             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22437 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22438             BOOT_JDK_FOUND=no
22439           else
22440             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22441             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22442 
22443             # Extra M4 quote needed to protect [] in grep expression.
22444             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
22445             if test "x$FOUND_CORRECT_VERSION" = x; then
22446               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22447 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22448               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
22449 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
22450               BOOT_JDK_FOUND=no
22451             else
22452               # We're done! :-)
22453               BOOT_JDK_FOUND=yes
22454 
22455   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22456 
22457   # Input might be given as Windows format, start by converting to
22458   # unix format.
22459   path="$BOOT_JDK"
22460   new_path=`$CYGPATH -u "$path"`
22461 
22462   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22463   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22464   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22465   # "foo.exe" is OK but "foo" is an error.
22466   #
22467   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22468   # It is also a way to make sure we got the proper file name for the real test later on.
22469   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22470   if test "x$test_shortpath" = x; then
22471     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22472 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22473     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22474   fi
22475 
22476   # Call helper function which possibly converts this using DOS-style short mode.
22477   # If so, the updated path is stored in $new_path.
22478 
22479   input_path="$new_path"
22480   # Check if we need to convert this using DOS-style short mode. If the path
22481   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22482   # take no chances and rewrite it.
22483   # Note: m4 eats our [], so we need to use [ and ] instead.
22484   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22485   if test "x$has_forbidden_chars" != x; then
22486     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22487     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22488     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22489     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22490       # Going to short mode and back again did indeed matter. Since short mode is
22491       # case insensitive, let's make it lowercase to improve readability.
22492       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22493       # Now convert it back to Unix-stile (cygpath)
22494       input_path=`$CYGPATH -u "$shortmode_path"`
22495       new_path="$input_path"
22496     fi
22497   fi
22498 
22499   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22500   if test "x$test_cygdrive_prefix" = x; then
22501     # As a simple fix, exclude /usr/bin since it's not a real path.
22502     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22503       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22504       # a path prefixed by /cygdrive for fixpath to work.
22505       new_path="$CYGWIN_ROOT_PATH$input_path"
22506     fi
22507   fi
22508 
22509 
22510   if test "x$path" != "x$new_path"; then
22511     BOOT_JDK="$new_path"
22512     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22513 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22514   fi
22515 
22516   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22517 
22518   path="$BOOT_JDK"
22519   has_colon=`$ECHO $path | $GREP ^.:`
22520   new_path="$path"
22521   if test "x$has_colon" = x; then
22522     # Not in mixed or Windows style, start by that.
22523     new_path=`cmd //c echo $path`
22524   fi
22525 
22526 
22527   input_path="$new_path"
22528   # Check if we need to convert this using DOS-style short mode. If the path
22529   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22530   # take no chances and rewrite it.
22531   # Note: m4 eats our [], so we need to use [ and ] instead.
22532   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22533   if test "x$has_forbidden_chars" != x; then
22534     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22535     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22536   fi
22537 
22538 
22539   windows_path="$new_path"
22540   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22541     unix_path=`$CYGPATH -u "$windows_path"`
22542     new_path="$unix_path"
22543   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22544     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22545     new_path="$unix_path"
22546   fi
22547 
22548   if test "x$path" != "x$new_path"; then
22549     BOOT_JDK="$new_path"
22550     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22551 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22552   fi
22553 
22554   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22555   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22556 
22557   else
22558     # We're on a posix platform. Hooray! :)
22559     path="$BOOT_JDK"
22560     has_space=`$ECHO "$path" | $GREP " "`
22561     if test "x$has_space" != x; then
22562       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22563 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22564       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22565     fi
22566 
22567     # Use eval to expand a potential ~
22568     eval path="$path"
22569     if test ! -f "$path" && test ! -d "$path"; then
22570       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22571     fi
22572 
22573     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22574   fi
22575 
22576               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22577 $as_echo_n "checking for Boot JDK... " >&6; }
22578               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22579 $as_echo "$BOOT_JDK" >&6; }
22580               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22581 $as_echo_n "checking Boot JDK version... " >&6; }
22582               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22583               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22584 $as_echo "$BOOT_JDK_VERSION" >&6; }
22585             fi # end check jdk version
22586           fi # end check rt.jar
22587         fi # end check javac
22588       fi # end check java
22589     fi # end check boot jdk found
22590   fi
22591 
22592     done
22593   fi
22594 
22595   fi
22596 
22597 
22598     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22599     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22600       # Do we have a bin/java?
22601       if test ! -x "$BOOT_JDK/bin/java"; then
22602         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22603 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22604         BOOT_JDK_FOUND=no
22605       else
22606         # Do we have a bin/javac?
22607         if test ! -x "$BOOT_JDK/bin/javac"; then
22608           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22609 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22610           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22611 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22612           BOOT_JDK_FOUND=no
22613         else
22614           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22615           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22616             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22617 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22618             BOOT_JDK_FOUND=no
22619           else
22620             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22621             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22622 
22623             # Extra M4 quote needed to protect [] in grep expression.
22624             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
22625             if test "x$FOUND_CORRECT_VERSION" = x; then
22626               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22627 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22628               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
22629 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
22630               BOOT_JDK_FOUND=no
22631             else
22632               # We're done! :-)
22633               BOOT_JDK_FOUND=yes
22634 
22635   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22636 
22637   # Input might be given as Windows format, start by converting to
22638   # unix format.
22639   path="$BOOT_JDK"
22640   new_path=`$CYGPATH -u "$path"`
22641 
22642   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22643   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22644   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22645   # "foo.exe" is OK but "foo" is an error.
22646   #
22647   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22648   # It is also a way to make sure we got the proper file name for the real test later on.
22649   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22650   if test "x$test_shortpath" = x; then
22651     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22652 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22653     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22654   fi
22655 
22656   # Call helper function which possibly converts this using DOS-style short mode.
22657   # If so, the updated path is stored in $new_path.
22658 
22659   input_path="$new_path"
22660   # Check if we need to convert this using DOS-style short mode. If the path
22661   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22662   # take no chances and rewrite it.
22663   # Note: m4 eats our [], so we need to use [ and ] instead.
22664   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22665   if test "x$has_forbidden_chars" != x; then
22666     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22667     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22668     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22669     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22670       # Going to short mode and back again did indeed matter. Since short mode is
22671       # case insensitive, let's make it lowercase to improve readability.
22672       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22673       # Now convert it back to Unix-stile (cygpath)
22674       input_path=`$CYGPATH -u "$shortmode_path"`
22675       new_path="$input_path"
22676     fi
22677   fi
22678 
22679   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22680   if test "x$test_cygdrive_prefix" = x; then
22681     # As a simple fix, exclude /usr/bin since it's not a real path.
22682     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22683       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22684       # a path prefixed by /cygdrive for fixpath to work.
22685       new_path="$CYGWIN_ROOT_PATH$input_path"
22686     fi
22687   fi
22688 
22689 
22690   if test "x$path" != "x$new_path"; then
22691     BOOT_JDK="$new_path"
22692     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22693 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22694   fi
22695 
22696   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22697 
22698   path="$BOOT_JDK"
22699   has_colon=`$ECHO $path | $GREP ^.:`
22700   new_path="$path"
22701   if test "x$has_colon" = x; then
22702     # Not in mixed or Windows style, start by that.
22703     new_path=`cmd //c echo $path`
22704   fi
22705 
22706 
22707   input_path="$new_path"
22708   # Check if we need to convert this using DOS-style short mode. If the path
22709   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22710   # take no chances and rewrite it.
22711   # Note: m4 eats our [], so we need to use [ and ] instead.
22712   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22713   if test "x$has_forbidden_chars" != x; then
22714     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22715     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22716   fi
22717 
22718 
22719   windows_path="$new_path"
22720   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22721     unix_path=`$CYGPATH -u "$windows_path"`
22722     new_path="$unix_path"
22723   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22724     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22725     new_path="$unix_path"
22726   fi
22727 
22728   if test "x$path" != "x$new_path"; then
22729     BOOT_JDK="$new_path"
22730     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22731 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22732   fi
22733 
22734   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22735   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22736 
22737   else
22738     # We're on a posix platform. Hooray! :)
22739     path="$BOOT_JDK"
22740     has_space=`$ECHO "$path" | $GREP " "`
22741     if test "x$has_space" != x; then
22742       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22743 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22744       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22745     fi
22746 
22747     # Use eval to expand a potential ~
22748     eval path="$path"
22749     if test ! -f "$path" && test ! -d "$path"; then
22750       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22751     fi
22752 
22753     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22754   fi
22755 
22756               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22757 $as_echo_n "checking for Boot JDK... " >&6; }
22758               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22759 $as_echo "$BOOT_JDK" >&6; }
22760               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22761 $as_echo_n "checking Boot JDK version... " >&6; }
22762               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22763               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22764 $as_echo "$BOOT_JDK_VERSION" >&6; }
22765             fi # end check jdk version
22766           fi # end check rt.jar
22767         fi # end check javac
22768       fi # end check java
22769     fi # end check boot jdk found
22770   fi
22771 
22772 
22773   if test "x$BOOT_JDK_FOUND" = xno; then
22774     # Now execute the test
22775 
22776   if test "x$ProgramFiles" != x; then
22777     VIRTUAL_DIR="$ProgramFiles/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           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22823           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22824             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22825 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22826             BOOT_JDK_FOUND=no
22827           else
22828             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22829             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22830 
22831             # Extra M4 quote needed to protect [] in grep expression.
22832             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
22833             if test "x$FOUND_CORRECT_VERSION" = x; then
22834               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22835 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22836               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
22837 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
22838               BOOT_JDK_FOUND=no
22839             else
22840               # We're done! :-)
22841               BOOT_JDK_FOUND=yes
22842 
22843   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22844 
22845   # Input might be given as Windows format, start by converting to
22846   # unix format.
22847   path="$BOOT_JDK"
22848   new_path=`$CYGPATH -u "$path"`
22849 
22850   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22851   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22852   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22853   # "foo.exe" is OK but "foo" is an error.
22854   #
22855   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22856   # It is also a way to make sure we got the proper file name for the real test later on.
22857   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22858   if test "x$test_shortpath" = x; then
22859     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22860 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22861     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22862   fi
22863 
22864   # Call helper function which possibly converts this using DOS-style short mode.
22865   # If so, the updated path is stored in $new_path.
22866 
22867   input_path="$new_path"
22868   # Check if we need to convert this using DOS-style short mode. If the path
22869   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22870   # take no chances and rewrite it.
22871   # Note: m4 eats our [], so we need to use [ and ] instead.
22872   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22873   if test "x$has_forbidden_chars" != x; then
22874     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22875     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22876     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22877     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22878       # Going to short mode and back again did indeed matter. Since short mode is
22879       # case insensitive, let's make it lowercase to improve readability.
22880       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22881       # Now convert it back to Unix-stile (cygpath)
22882       input_path=`$CYGPATH -u "$shortmode_path"`
22883       new_path="$input_path"
22884     fi
22885   fi
22886 
22887   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22888   if test "x$test_cygdrive_prefix" = x; then
22889     # As a simple fix, exclude /usr/bin since it's not a real path.
22890     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22891       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22892       # a path prefixed by /cygdrive for fixpath to work.
22893       new_path="$CYGWIN_ROOT_PATH$input_path"
22894     fi
22895   fi
22896 
22897 
22898   if test "x$path" != "x$new_path"; then
22899     BOOT_JDK="$new_path"
22900     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22901 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22902   fi
22903 
22904   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22905 
22906   path="$BOOT_JDK"
22907   has_colon=`$ECHO $path | $GREP ^.:`
22908   new_path="$path"
22909   if test "x$has_colon" = x; then
22910     # Not in mixed or Windows style, start by that.
22911     new_path=`cmd //c echo $path`
22912   fi
22913 
22914 
22915   input_path="$new_path"
22916   # Check if we need to convert this using DOS-style short mode. If the path
22917   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22918   # take no chances and rewrite it.
22919   # Note: m4 eats our [], so we need to use [ and ] instead.
22920   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22921   if test "x$has_forbidden_chars" != x; then
22922     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22923     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22924   fi
22925 
22926 
22927   windows_path="$new_path"
22928   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22929     unix_path=`$CYGPATH -u "$windows_path"`
22930     new_path="$unix_path"
22931   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22932     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22933     new_path="$unix_path"
22934   fi
22935 
22936   if test "x$path" != "x$new_path"; then
22937     BOOT_JDK="$new_path"
22938     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22939 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22940   fi
22941 
22942   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22943   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22944 
22945   else
22946     # We're on a posix platform. Hooray! :)
22947     path="$BOOT_JDK"
22948     has_space=`$ECHO "$path" | $GREP " "`
22949     if test "x$has_space" != x; then
22950       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22951 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22952       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22953     fi
22954 
22955     # Use eval to expand a potential ~
22956     eval path="$path"
22957     if test ! -f "$path" && test ! -d "$path"; then
22958       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22959     fi
22960 
22961     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22962   fi
22963 
22964               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22965 $as_echo_n "checking for Boot JDK... " >&6; }
22966               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22967 $as_echo "$BOOT_JDK" >&6; }
22968               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22969 $as_echo_n "checking Boot JDK version... " >&6; }
22970               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22971               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22972 $as_echo "$BOOT_JDK_VERSION" >&6; }
22973             fi # end check jdk version
22974           fi # end check rt.jar
22975         fi # end check javac
22976       fi # end check java
22977     fi # end check boot jdk found
22978   fi
22979 
22980     done
22981   fi
22982 
22983   fi
22984 
22985 
22986     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22987     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22988       # Do we have a bin/java?
22989       if test ! -x "$BOOT_JDK/bin/java"; then
22990         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22991 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22992         BOOT_JDK_FOUND=no
22993       else
22994         # Do we have a bin/javac?
22995         if test ! -x "$BOOT_JDK/bin/javac"; then
22996           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22997 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22998           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22999 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23000           BOOT_JDK_FOUND=no
23001         else
23002           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23003           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23004             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23005 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23006             BOOT_JDK_FOUND=no
23007           else
23008             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23009             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23010 
23011             # Extra M4 quote needed to protect [] in grep expression.
23012             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
23013             if test "x$FOUND_CORRECT_VERSION" = x; then
23014               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23015 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23016               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
23017 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
23018               BOOT_JDK_FOUND=no
23019             else
23020               # We're done! :-)
23021               BOOT_JDK_FOUND=yes
23022 
23023   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23024 
23025   # Input might be given as Windows format, start by converting to
23026   # unix format.
23027   path="$BOOT_JDK"
23028   new_path=`$CYGPATH -u "$path"`
23029 
23030   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23031   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23032   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23033   # "foo.exe" is OK but "foo" is an error.
23034   #
23035   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23036   # It is also a way to make sure we got the proper file name for the real test later on.
23037   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23038   if test "x$test_shortpath" = x; then
23039     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23040 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23041     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23042   fi
23043 
23044   # Call helper function which possibly converts this using DOS-style short mode.
23045   # If so, the updated path is stored in $new_path.
23046 
23047   input_path="$new_path"
23048   # Check if we need to convert this using DOS-style short mode. If the path
23049   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23050   # take no chances and rewrite it.
23051   # Note: m4 eats our [], so we need to use [ and ] instead.
23052   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23053   if test "x$has_forbidden_chars" != x; then
23054     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23055     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23056     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23057     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23058       # Going to short mode and back again did indeed matter. Since short mode is
23059       # case insensitive, let's make it lowercase to improve readability.
23060       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23061       # Now convert it back to Unix-stile (cygpath)
23062       input_path=`$CYGPATH -u "$shortmode_path"`
23063       new_path="$input_path"
23064     fi
23065   fi
23066 
23067   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23068   if test "x$test_cygdrive_prefix" = x; then
23069     # As a simple fix, exclude /usr/bin since it's not a real path.
23070     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23071       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23072       # a path prefixed by /cygdrive for fixpath to work.
23073       new_path="$CYGWIN_ROOT_PATH$input_path"
23074     fi
23075   fi
23076 
23077 
23078   if test "x$path" != "x$new_path"; then
23079     BOOT_JDK="$new_path"
23080     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23081 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23082   fi
23083 
23084   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23085 
23086   path="$BOOT_JDK"
23087   has_colon=`$ECHO $path | $GREP ^.:`
23088   new_path="$path"
23089   if test "x$has_colon" = x; then
23090     # Not in mixed or Windows style, start by that.
23091     new_path=`cmd //c echo $path`
23092   fi
23093 
23094 
23095   input_path="$new_path"
23096   # Check if we need to convert this using DOS-style short mode. If the path
23097   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23098   # take no chances and rewrite it.
23099   # Note: m4 eats our [], so we need to use [ and ] instead.
23100   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23101   if test "x$has_forbidden_chars" != x; then
23102     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23103     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23104   fi
23105 
23106 
23107   windows_path="$new_path"
23108   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23109     unix_path=`$CYGPATH -u "$windows_path"`
23110     new_path="$unix_path"
23111   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23112     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23113     new_path="$unix_path"
23114   fi
23115 
23116   if test "x$path" != "x$new_path"; then
23117     BOOT_JDK="$new_path"
23118     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23119 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23120   fi
23121 
23122   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23123   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23124 
23125   else
23126     # We're on a posix platform. Hooray! :)
23127     path="$BOOT_JDK"
23128     has_space=`$ECHO "$path" | $GREP " "`
23129     if test "x$has_space" != x; then
23130       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23131 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23132       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23133     fi
23134 
23135     # Use eval to expand a potential ~
23136     eval path="$path"
23137     if test ! -f "$path" && test ! -d "$path"; then
23138       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23139     fi
23140 
23141     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23142   fi
23143 
23144               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23145 $as_echo_n "checking for Boot JDK... " >&6; }
23146               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23147 $as_echo "$BOOT_JDK" >&6; }
23148               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23149 $as_echo_n "checking Boot JDK version... " >&6; }
23150               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23151               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23152 $as_echo "$BOOT_JDK_VERSION" >&6; }
23153             fi # end check jdk version
23154           fi # end check rt.jar
23155         fi # end check javac
23156       fi # end check java
23157     fi # end check boot jdk found
23158   fi
23159 
23160 
23161   if test "x$BOOT_JDK_FOUND" = xno; then
23162     # Now execute the test
23163 
23164   BOOT_JDK_PREFIX="/cygdrive/c/Program Files/Java"
23165   BOOT_JDK_SUFFIX=""
23166   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23167   if test "x$ALL_JDKS_FOUND" != x; then
23168     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23169 
23170   if test "x$BOOT_JDK_FOUND" = xno; then
23171     # Now execute the test
23172 
23173         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23174         if test -d "$BOOT_JDK"; then
23175           BOOT_JDK_FOUND=maybe
23176           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23177 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23178         fi
23179 
23180 
23181     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23182     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23183       # Do we have a bin/java?
23184       if test ! -x "$BOOT_JDK/bin/java"; then
23185         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23186 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23187         BOOT_JDK_FOUND=no
23188       else
23189         # Do we have a bin/javac?
23190         if test ! -x "$BOOT_JDK/bin/javac"; then
23191           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23192 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23193           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23194 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23195           BOOT_JDK_FOUND=no
23196         else
23197           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23198           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23199             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23200 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23201             BOOT_JDK_FOUND=no
23202           else
23203             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23204             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23205 
23206             # Extra M4 quote needed to protect [] in grep expression.
23207             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
23208             if test "x$FOUND_CORRECT_VERSION" = x; then
23209               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23210 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23211               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
23212 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
23213               BOOT_JDK_FOUND=no
23214             else
23215               # We're done! :-)
23216               BOOT_JDK_FOUND=yes
23217 
23218   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23219 
23220   # Input might be given as Windows format, start by converting to
23221   # unix format.
23222   path="$BOOT_JDK"
23223   new_path=`$CYGPATH -u "$path"`
23224 
23225   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23226   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23227   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23228   # "foo.exe" is OK but "foo" is an error.
23229   #
23230   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23231   # It is also a way to make sure we got the proper file name for the real test later on.
23232   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23233   if test "x$test_shortpath" = x; then
23234     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23235 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23236     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23237   fi
23238 
23239   # Call helper function which possibly converts this using DOS-style short mode.
23240   # If so, the updated path is stored in $new_path.
23241 
23242   input_path="$new_path"
23243   # Check if we need to convert this using DOS-style short mode. If the path
23244   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23245   # take no chances and rewrite it.
23246   # Note: m4 eats our [], so we need to use [ and ] instead.
23247   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23248   if test "x$has_forbidden_chars" != x; then
23249     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23250     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23251     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23252     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23253       # Going to short mode and back again did indeed matter. Since short mode is
23254       # case insensitive, let's make it lowercase to improve readability.
23255       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23256       # Now convert it back to Unix-stile (cygpath)
23257       input_path=`$CYGPATH -u "$shortmode_path"`
23258       new_path="$input_path"
23259     fi
23260   fi
23261 
23262   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23263   if test "x$test_cygdrive_prefix" = x; then
23264     # As a simple fix, exclude /usr/bin since it's not a real path.
23265     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23266       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23267       # a path prefixed by /cygdrive for fixpath to work.
23268       new_path="$CYGWIN_ROOT_PATH$input_path"
23269     fi
23270   fi
23271 
23272 
23273   if test "x$path" != "x$new_path"; then
23274     BOOT_JDK="$new_path"
23275     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23276 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23277   fi
23278 
23279   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23280 
23281   path="$BOOT_JDK"
23282   has_colon=`$ECHO $path | $GREP ^.:`
23283   new_path="$path"
23284   if test "x$has_colon" = x; then
23285     # Not in mixed or Windows style, start by that.
23286     new_path=`cmd //c echo $path`
23287   fi
23288 
23289 
23290   input_path="$new_path"
23291   # Check if we need to convert this using DOS-style short mode. If the path
23292   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23293   # take no chances and rewrite it.
23294   # Note: m4 eats our [], so we need to use [ and ] instead.
23295   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23296   if test "x$has_forbidden_chars" != x; then
23297     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23298     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23299   fi
23300 
23301 
23302   windows_path="$new_path"
23303   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23304     unix_path=`$CYGPATH -u "$windows_path"`
23305     new_path="$unix_path"
23306   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23307     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23308     new_path="$unix_path"
23309   fi
23310 
23311   if test "x$path" != "x$new_path"; then
23312     BOOT_JDK="$new_path"
23313     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23314 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23315   fi
23316 
23317   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23318   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23319 
23320   else
23321     # We're on a posix platform. Hooray! :)
23322     path="$BOOT_JDK"
23323     has_space=`$ECHO "$path" | $GREP " "`
23324     if test "x$has_space" != x; then
23325       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23326 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23327       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23328     fi
23329 
23330     # Use eval to expand a potential ~
23331     eval path="$path"
23332     if test ! -f "$path" && test ! -d "$path"; then
23333       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23334     fi
23335 
23336     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23337   fi
23338 
23339               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23340 $as_echo_n "checking for Boot JDK... " >&6; }
23341               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23342 $as_echo "$BOOT_JDK" >&6; }
23343               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23344 $as_echo_n "checking Boot JDK version... " >&6; }
23345               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23346               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23347 $as_echo "$BOOT_JDK_VERSION" >&6; }
23348             fi # end check jdk version
23349           fi # end check rt.jar
23350         fi # end check javac
23351       fi # end check java
23352     fi # end check boot jdk found
23353   fi
23354 
23355     done
23356   fi
23357 
23358 
23359     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23360     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23361       # Do we have a bin/java?
23362       if test ! -x "$BOOT_JDK/bin/java"; then
23363         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23364 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23365         BOOT_JDK_FOUND=no
23366       else
23367         # Do we have a bin/javac?
23368         if test ! -x "$BOOT_JDK/bin/javac"; then
23369           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23370 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23371           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23372 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23373           BOOT_JDK_FOUND=no
23374         else
23375           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23376           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23377             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23378 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&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\.[789]\.'`
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 7, 8 or 9)" >&5
23390 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
23391               BOOT_JDK_FOUND=no
23392             else
23393               # We're done! :-)
23394               BOOT_JDK_FOUND=yes
23395 
23396   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23397 
23398   # Input might be given as Windows format, start by converting to
23399   # unix format.
23400   path="$BOOT_JDK"
23401   new_path=`$CYGPATH -u "$path"`
23402 
23403   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23404   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23405   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23406   # "foo.exe" is OK but "foo" is an error.
23407   #
23408   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23409   # It is also a way to make sure we got the proper file name for the real test later on.
23410   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23411   if test "x$test_shortpath" = x; then
23412     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23413 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23414     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23415   fi
23416 
23417   # Call helper function which possibly converts this using DOS-style short mode.
23418   # If so, the updated path is stored in $new_path.
23419 
23420   input_path="$new_path"
23421   # Check if we need to convert this using DOS-style short mode. If the path
23422   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23423   # take no chances and rewrite it.
23424   # Note: m4 eats our [], so we need to use [ and ] instead.
23425   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23426   if test "x$has_forbidden_chars" != x; then
23427     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23428     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23429     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23430     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23431       # Going to short mode and back again did indeed matter. Since short mode is
23432       # case insensitive, let's make it lowercase to improve readability.
23433       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23434       # Now convert it back to Unix-stile (cygpath)
23435       input_path=`$CYGPATH -u "$shortmode_path"`
23436       new_path="$input_path"
23437     fi
23438   fi
23439 
23440   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23441   if test "x$test_cygdrive_prefix" = x; then
23442     # As a simple fix, exclude /usr/bin since it's not a real path.
23443     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23444       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23445       # a path prefixed by /cygdrive for fixpath to work.
23446       new_path="$CYGWIN_ROOT_PATH$input_path"
23447     fi
23448   fi
23449 
23450 
23451   if test "x$path" != "x$new_path"; then
23452     BOOT_JDK="$new_path"
23453     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23454 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23455   fi
23456 
23457   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23458 
23459   path="$BOOT_JDK"
23460   has_colon=`$ECHO $path | $GREP ^.:`
23461   new_path="$path"
23462   if test "x$has_colon" = x; then
23463     # Not in mixed or Windows style, start by that.
23464     new_path=`cmd //c echo $path`
23465   fi
23466 
23467 
23468   input_path="$new_path"
23469   # Check if we need to convert this using DOS-style short mode. If the path
23470   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23471   # take no chances and rewrite it.
23472   # Note: m4 eats our [], so we need to use [ and ] instead.
23473   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23474   if test "x$has_forbidden_chars" != x; then
23475     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23476     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23477   fi
23478 
23479 
23480   windows_path="$new_path"
23481   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23482     unix_path=`$CYGPATH -u "$windows_path"`
23483     new_path="$unix_path"
23484   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23485     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23486     new_path="$unix_path"
23487   fi
23488 
23489   if test "x$path" != "x$new_path"; then
23490     BOOT_JDK="$new_path"
23491     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23492 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23493   fi
23494 
23495   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23496   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23497 
23498   else
23499     # We're on a posix platform. Hooray! :)
23500     path="$BOOT_JDK"
23501     has_space=`$ECHO "$path" | $GREP " "`
23502     if test "x$has_space" != x; then
23503       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23504 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23505       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23506     fi
23507 
23508     # Use eval to expand a potential ~
23509     eval path="$path"
23510     if test ! -f "$path" && test ! -d "$path"; then
23511       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23512     fi
23513 
23514     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23515   fi
23516 
23517               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23518 $as_echo_n "checking for Boot JDK... " >&6; }
23519               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23520 $as_echo "$BOOT_JDK" >&6; }
23521               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23522 $as_echo_n "checking Boot JDK version... " >&6; }
23523               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23524               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23525 $as_echo "$BOOT_JDK_VERSION" >&6; }
23526             fi # end check jdk version
23527           fi # end check rt.jar
23528         fi # end check javac
23529       fi # end check java
23530     fi # end check boot jdk found
23531   fi
23532 
23533   elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
23534 
23535   if test "x$BOOT_JDK_FOUND" = xno; then
23536     # Now execute the test
23537 
23538   BOOT_JDK_PREFIX="/Library/Java/JavaVirtualMachines"
23539   BOOT_JDK_SUFFIX="/Contents/Home"
23540   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23541   if test "x$ALL_JDKS_FOUND" != x; then
23542     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23543 
23544   if test "x$BOOT_JDK_FOUND" = xno; then
23545     # Now execute the test
23546 
23547         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23548         if test -d "$BOOT_JDK"; then
23549           BOOT_JDK_FOUND=maybe
23550           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23551 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23552         fi
23553 
23554 
23555     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23556     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23557       # Do we have a bin/java?
23558       if test ! -x "$BOOT_JDK/bin/java"; then
23559         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23560 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23561         BOOT_JDK_FOUND=no
23562       else
23563         # Do we have a bin/javac?
23564         if test ! -x "$BOOT_JDK/bin/javac"; then
23565           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23566 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23567           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23568 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23569           BOOT_JDK_FOUND=no
23570         else
23571           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23572           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23573             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23574 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23575             BOOT_JDK_FOUND=no
23576           else
23577             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23578             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23579 
23580             # Extra M4 quote needed to protect [] in grep expression.
23581             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
23582             if test "x$FOUND_CORRECT_VERSION" = x; then
23583               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23584 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23585               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
23586 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
23587               BOOT_JDK_FOUND=no
23588             else
23589               # We're done! :-)
23590               BOOT_JDK_FOUND=yes
23591 
23592   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23593 
23594   # Input might be given as Windows format, start by converting to
23595   # unix format.
23596   path="$BOOT_JDK"
23597   new_path=`$CYGPATH -u "$path"`
23598 
23599   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23600   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23601   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23602   # "foo.exe" is OK but "foo" is an error.
23603   #
23604   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23605   # It is also a way to make sure we got the proper file name for the real test later on.
23606   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23607   if test "x$test_shortpath" = x; then
23608     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23609 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23610     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23611   fi
23612 
23613   # Call helper function which possibly converts this using DOS-style short mode.
23614   # If so, the updated path is stored in $new_path.
23615 
23616   input_path="$new_path"
23617   # Check if we need to convert this using DOS-style short mode. If the path
23618   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23619   # take no chances and rewrite it.
23620   # Note: m4 eats our [], so we need to use [ and ] instead.
23621   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23622   if test "x$has_forbidden_chars" != x; then
23623     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23624     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23625     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23626     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23627       # Going to short mode and back again did indeed matter. Since short mode is
23628       # case insensitive, let's make it lowercase to improve readability.
23629       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23630       # Now convert it back to Unix-stile (cygpath)
23631       input_path=`$CYGPATH -u "$shortmode_path"`
23632       new_path="$input_path"
23633     fi
23634   fi
23635 
23636   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23637   if test "x$test_cygdrive_prefix" = x; then
23638     # As a simple fix, exclude /usr/bin since it's not a real path.
23639     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23640       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23641       # a path prefixed by /cygdrive for fixpath to work.
23642       new_path="$CYGWIN_ROOT_PATH$input_path"
23643     fi
23644   fi
23645 
23646 
23647   if test "x$path" != "x$new_path"; then
23648     BOOT_JDK="$new_path"
23649     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23650 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23651   fi
23652 
23653   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23654 
23655   path="$BOOT_JDK"
23656   has_colon=`$ECHO $path | $GREP ^.:`
23657   new_path="$path"
23658   if test "x$has_colon" = x; then
23659     # Not in mixed or Windows style, start by that.
23660     new_path=`cmd //c echo $path`
23661   fi
23662 
23663 
23664   input_path="$new_path"
23665   # Check if we need to convert this using DOS-style short mode. If the path
23666   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23667   # take no chances and rewrite it.
23668   # Note: m4 eats our [], so we need to use [ and ] instead.
23669   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23670   if test "x$has_forbidden_chars" != x; then
23671     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23672     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23673   fi
23674 
23675 
23676   windows_path="$new_path"
23677   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23678     unix_path=`$CYGPATH -u "$windows_path"`
23679     new_path="$unix_path"
23680   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23681     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23682     new_path="$unix_path"
23683   fi
23684 
23685   if test "x$path" != "x$new_path"; then
23686     BOOT_JDK="$new_path"
23687     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23688 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23689   fi
23690 
23691   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23692   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23693 
23694   else
23695     # We're on a posix platform. Hooray! :)
23696     path="$BOOT_JDK"
23697     has_space=`$ECHO "$path" | $GREP " "`
23698     if test "x$has_space" != x; then
23699       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23700 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23701       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23702     fi
23703 
23704     # Use eval to expand a potential ~
23705     eval path="$path"
23706     if test ! -f "$path" && test ! -d "$path"; then
23707       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23708     fi
23709 
23710     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23711   fi
23712 
23713               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23714 $as_echo_n "checking for Boot JDK... " >&6; }
23715               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23716 $as_echo "$BOOT_JDK" >&6; }
23717               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23718 $as_echo_n "checking Boot JDK version... " >&6; }
23719               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23720               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23721 $as_echo "$BOOT_JDK_VERSION" >&6; }
23722             fi # end check jdk version
23723           fi # end check rt.jar
23724         fi # end check javac
23725       fi # end check java
23726     fi # end check boot jdk found
23727   fi
23728 
23729     done
23730   fi
23731 
23732 
23733     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23734     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23735       # Do we have a bin/java?
23736       if test ! -x "$BOOT_JDK/bin/java"; then
23737         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23738 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23739         BOOT_JDK_FOUND=no
23740       else
23741         # Do we have a bin/javac?
23742         if test ! -x "$BOOT_JDK/bin/javac"; then
23743           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23744 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23745           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23746 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23747           BOOT_JDK_FOUND=no
23748         else
23749           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23750           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23751             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23752 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23753             BOOT_JDK_FOUND=no
23754           else
23755             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23756             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23757 
23758             # Extra M4 quote needed to protect [] in grep expression.
23759             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
23760             if test "x$FOUND_CORRECT_VERSION" = x; then
23761               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23762 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23763               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
23764 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
23765               BOOT_JDK_FOUND=no
23766             else
23767               # We're done! :-)
23768               BOOT_JDK_FOUND=yes
23769 
23770   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23771 
23772   # Input might be given as Windows format, start by converting to
23773   # unix format.
23774   path="$BOOT_JDK"
23775   new_path=`$CYGPATH -u "$path"`
23776 
23777   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23778   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23779   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23780   # "foo.exe" is OK but "foo" is an error.
23781   #
23782   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23783   # It is also a way to make sure we got the proper file name for the real test later on.
23784   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23785   if test "x$test_shortpath" = x; then
23786     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23787 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23788     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23789   fi
23790 
23791   # Call helper function which possibly converts this using DOS-style short mode.
23792   # If so, the updated path is stored in $new_path.
23793 
23794   input_path="$new_path"
23795   # Check if we need to convert this using DOS-style short mode. If the path
23796   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23797   # take no chances and rewrite it.
23798   # Note: m4 eats our [], so we need to use [ and ] instead.
23799   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23800   if test "x$has_forbidden_chars" != x; then
23801     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23802     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23803     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23804     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23805       # Going to short mode and back again did indeed matter. Since short mode is
23806       # case insensitive, let's make it lowercase to improve readability.
23807       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23808       # Now convert it back to Unix-stile (cygpath)
23809       input_path=`$CYGPATH -u "$shortmode_path"`
23810       new_path="$input_path"
23811     fi
23812   fi
23813 
23814   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23815   if test "x$test_cygdrive_prefix" = x; then
23816     # As a simple fix, exclude /usr/bin since it's not a real path.
23817     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23818       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23819       # a path prefixed by /cygdrive for fixpath to work.
23820       new_path="$CYGWIN_ROOT_PATH$input_path"
23821     fi
23822   fi
23823 
23824 
23825   if test "x$path" != "x$new_path"; then
23826     BOOT_JDK="$new_path"
23827     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23828 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23829   fi
23830 
23831   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23832 
23833   path="$BOOT_JDK"
23834   has_colon=`$ECHO $path | $GREP ^.:`
23835   new_path="$path"
23836   if test "x$has_colon" = x; then
23837     # Not in mixed or Windows style, start by that.
23838     new_path=`cmd //c echo $path`
23839   fi
23840 
23841 
23842   input_path="$new_path"
23843   # Check if we need to convert this using DOS-style short mode. If the path
23844   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23845   # take no chances and rewrite it.
23846   # Note: m4 eats our [], so we need to use [ and ] instead.
23847   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23848   if test "x$has_forbidden_chars" != x; then
23849     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23850     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23851   fi
23852 
23853 
23854   windows_path="$new_path"
23855   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23856     unix_path=`$CYGPATH -u "$windows_path"`
23857     new_path="$unix_path"
23858   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23859     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23860     new_path="$unix_path"
23861   fi
23862 
23863   if test "x$path" != "x$new_path"; then
23864     BOOT_JDK="$new_path"
23865     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23866 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23867   fi
23868 
23869   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23870   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23871 
23872   else
23873     # We're on a posix platform. Hooray! :)
23874     path="$BOOT_JDK"
23875     has_space=`$ECHO "$path" | $GREP " "`
23876     if test "x$has_space" != x; then
23877       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23878 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23879       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23880     fi
23881 
23882     # Use eval to expand a potential ~
23883     eval path="$path"
23884     if test ! -f "$path" && test ! -d "$path"; then
23885       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23886     fi
23887 
23888     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23889   fi
23890 
23891               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23892 $as_echo_n "checking for Boot JDK... " >&6; }
23893               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23894 $as_echo "$BOOT_JDK" >&6; }
23895               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23896 $as_echo_n "checking Boot JDK version... " >&6; }
23897               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23898               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23899 $as_echo "$BOOT_JDK_VERSION" >&6; }
23900             fi # end check jdk version
23901           fi # end check rt.jar
23902         fi # end check javac
23903       fi # end check java
23904     fi # end check boot jdk found
23905   fi
23906 
23907 
23908   if test "x$BOOT_JDK_FOUND" = xno; then
23909     # Now execute the test
23910 
23911   BOOT_JDK_PREFIX="/System/Library/Java/JavaVirtualMachines"
23912   BOOT_JDK_SUFFIX="/Contents/Home"
23913   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23914   if test "x$ALL_JDKS_FOUND" != x; then
23915     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23916 
23917   if test "x$BOOT_JDK_FOUND" = xno; then
23918     # Now execute the test
23919 
23920         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23921         if test -d "$BOOT_JDK"; then
23922           BOOT_JDK_FOUND=maybe
23923           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23924 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23925         fi
23926 
23927 
23928     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23929     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23930       # Do we have a bin/java?
23931       if test ! -x "$BOOT_JDK/bin/java"; then
23932         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23933 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23934         BOOT_JDK_FOUND=no
23935       else
23936         # Do we have a bin/javac?
23937         if test ! -x "$BOOT_JDK/bin/javac"; then
23938           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23939 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23940           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23941 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23942           BOOT_JDK_FOUND=no
23943         else
23944           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23945           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23946             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23947 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23948             BOOT_JDK_FOUND=no
23949           else
23950             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23951             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23952 
23953             # Extra M4 quote needed to protect [] in grep expression.
23954             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
23955             if test "x$FOUND_CORRECT_VERSION" = x; then
23956               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23957 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23958               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
23959 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
23960               BOOT_JDK_FOUND=no
23961             else
23962               # We're done! :-)
23963               BOOT_JDK_FOUND=yes
23964 
23965   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23966 
23967   # Input might be given as Windows format, start by converting to
23968   # unix format.
23969   path="$BOOT_JDK"
23970   new_path=`$CYGPATH -u "$path"`
23971 
23972   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23973   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23974   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23975   # "foo.exe" is OK but "foo" is an error.
23976   #
23977   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23978   # It is also a way to make sure we got the proper file name for the real test later on.
23979   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23980   if test "x$test_shortpath" = x; then
23981     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23982 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23983     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23984   fi
23985 
23986   # Call helper function which possibly converts this using DOS-style short mode.
23987   # If so, the updated path is stored in $new_path.
23988 
23989   input_path="$new_path"
23990   # Check if we need to convert this using DOS-style short mode. If the path
23991   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23992   # take no chances and rewrite it.
23993   # Note: m4 eats our [], so we need to use [ and ] instead.
23994   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23995   if test "x$has_forbidden_chars" != x; then
23996     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23997     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23998     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23999     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24000       # Going to short mode and back again did indeed matter. Since short mode is
24001       # case insensitive, let's make it lowercase to improve readability.
24002       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24003       # Now convert it back to Unix-stile (cygpath)
24004       input_path=`$CYGPATH -u "$shortmode_path"`
24005       new_path="$input_path"
24006     fi
24007   fi
24008 
24009   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24010   if test "x$test_cygdrive_prefix" = x; then
24011     # As a simple fix, exclude /usr/bin since it's not a real path.
24012     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24013       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24014       # a path prefixed by /cygdrive for fixpath to work.
24015       new_path="$CYGWIN_ROOT_PATH$input_path"
24016     fi
24017   fi
24018 
24019 
24020   if test "x$path" != "x$new_path"; then
24021     BOOT_JDK="$new_path"
24022     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24023 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24024   fi
24025 
24026   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24027 
24028   path="$BOOT_JDK"
24029   has_colon=`$ECHO $path | $GREP ^.:`
24030   new_path="$path"
24031   if test "x$has_colon" = x; then
24032     # Not in mixed or Windows style, start by that.
24033     new_path=`cmd //c echo $path`
24034   fi
24035 
24036 
24037   input_path="$new_path"
24038   # Check if we need to convert this using DOS-style short mode. If the path
24039   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24040   # take no chances and rewrite it.
24041   # Note: m4 eats our [], so we need to use [ and ] instead.
24042   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24043   if test "x$has_forbidden_chars" != x; then
24044     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24045     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24046   fi
24047 
24048 
24049   windows_path="$new_path"
24050   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24051     unix_path=`$CYGPATH -u "$windows_path"`
24052     new_path="$unix_path"
24053   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24054     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24055     new_path="$unix_path"
24056   fi
24057 
24058   if test "x$path" != "x$new_path"; then
24059     BOOT_JDK="$new_path"
24060     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24061 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24062   fi
24063 
24064   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24065   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24066 
24067   else
24068     # We're on a posix platform. Hooray! :)
24069     path="$BOOT_JDK"
24070     has_space=`$ECHO "$path" | $GREP " "`
24071     if test "x$has_space" != x; then
24072       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24073 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24074       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24075     fi
24076 
24077     # Use eval to expand a potential ~
24078     eval path="$path"
24079     if test ! -f "$path" && test ! -d "$path"; then
24080       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24081     fi
24082 
24083     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24084   fi
24085 
24086               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24087 $as_echo_n "checking for Boot JDK... " >&6; }
24088               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24089 $as_echo "$BOOT_JDK" >&6; }
24090               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24091 $as_echo_n "checking Boot JDK version... " >&6; }
24092               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24093               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24094 $as_echo "$BOOT_JDK_VERSION" >&6; }
24095             fi # end check jdk version
24096           fi # end check rt.jar
24097         fi # end check javac
24098       fi # end check java
24099     fi # end check boot jdk found
24100   fi
24101 
24102     done
24103   fi
24104 
24105 
24106     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24107     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24108       # Do we have a bin/java?
24109       if test ! -x "$BOOT_JDK/bin/java"; then
24110         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24111 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24112         BOOT_JDK_FOUND=no
24113       else
24114         # Do we have a bin/javac?
24115         if test ! -x "$BOOT_JDK/bin/javac"; then
24116           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24117 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24118           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24119 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24120           BOOT_JDK_FOUND=no
24121         else
24122           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
24123           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
24124             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
24125 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
24126             BOOT_JDK_FOUND=no
24127           else
24128             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24129             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24130 
24131             # Extra M4 quote needed to protect [] in grep expression.
24132             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
24133             if test "x$FOUND_CORRECT_VERSION" = x; then
24134               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24135 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24136               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
24137 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
24138               BOOT_JDK_FOUND=no
24139             else
24140               # We're done! :-)
24141               BOOT_JDK_FOUND=yes
24142 
24143   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24144 
24145   # Input might be given as Windows format, start by converting to
24146   # unix format.
24147   path="$BOOT_JDK"
24148   new_path=`$CYGPATH -u "$path"`
24149 
24150   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24151   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24152   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24153   # "foo.exe" is OK but "foo" is an error.
24154   #
24155   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24156   # It is also a way to make sure we got the proper file name for the real test later on.
24157   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24158   if test "x$test_shortpath" = x; then
24159     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24160 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24161     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24162   fi
24163 
24164   # Call helper function which possibly converts this using DOS-style short mode.
24165   # If so, the updated path is stored in $new_path.
24166 
24167   input_path="$new_path"
24168   # Check if we need to convert this using DOS-style short mode. If the path
24169   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24170   # take no chances and rewrite it.
24171   # Note: m4 eats our [], so we need to use [ and ] instead.
24172   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24173   if test "x$has_forbidden_chars" != x; then
24174     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24175     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24176     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24177     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24178       # Going to short mode and back again did indeed matter. Since short mode is
24179       # case insensitive, let's make it lowercase to improve readability.
24180       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24181       # Now convert it back to Unix-stile (cygpath)
24182       input_path=`$CYGPATH -u "$shortmode_path"`
24183       new_path="$input_path"
24184     fi
24185   fi
24186 
24187   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24188   if test "x$test_cygdrive_prefix" = x; then
24189     # As a simple fix, exclude /usr/bin since it's not a real path.
24190     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24191       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24192       # a path prefixed by /cygdrive for fixpath to work.
24193       new_path="$CYGWIN_ROOT_PATH$input_path"
24194     fi
24195   fi
24196 
24197 
24198   if test "x$path" != "x$new_path"; then
24199     BOOT_JDK="$new_path"
24200     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24201 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24202   fi
24203 
24204   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24205 
24206   path="$BOOT_JDK"
24207   has_colon=`$ECHO $path | $GREP ^.:`
24208   new_path="$path"
24209   if test "x$has_colon" = x; then
24210     # Not in mixed or Windows style, start by that.
24211     new_path=`cmd //c echo $path`
24212   fi
24213 
24214 
24215   input_path="$new_path"
24216   # Check if we need to convert this using DOS-style short mode. If the path
24217   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24218   # take no chances and rewrite it.
24219   # Note: m4 eats our [], so we need to use [ and ] instead.
24220   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24221   if test "x$has_forbidden_chars" != x; then
24222     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24223     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24224   fi
24225 
24226 
24227   windows_path="$new_path"
24228   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24229     unix_path=`$CYGPATH -u "$windows_path"`
24230     new_path="$unix_path"
24231   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24232     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24233     new_path="$unix_path"
24234   fi
24235 
24236   if test "x$path" != "x$new_path"; then
24237     BOOT_JDK="$new_path"
24238     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24239 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24240   fi
24241 
24242   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24243   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24244 
24245   else
24246     # We're on a posix platform. Hooray! :)
24247     path="$BOOT_JDK"
24248     has_space=`$ECHO "$path" | $GREP " "`
24249     if test "x$has_space" != x; then
24250       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24251 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24252       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24253     fi
24254 
24255     # Use eval to expand a potential ~
24256     eval path="$path"
24257     if test ! -f "$path" && test ! -d "$path"; then
24258       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24259     fi
24260 
24261     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24262   fi
24263 
24264               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24265 $as_echo_n "checking for Boot JDK... " >&6; }
24266               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24267 $as_echo "$BOOT_JDK" >&6; }
24268               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24269 $as_echo_n "checking Boot JDK version... " >&6; }
24270               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24271               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24272 $as_echo "$BOOT_JDK_VERSION" >&6; }
24273             fi # end check jdk version
24274           fi # end check rt.jar
24275         fi # end check javac
24276       fi # end check java
24277     fi # end check boot jdk found
24278   fi
24279 
24280   elif test "x$OPENJDK_TARGET_OS" = xlinux; then
24281 
24282   if test "x$BOOT_JDK_FOUND" = xno; then
24283     # Now execute the test
24284 
24285   BOOT_JDK_PREFIX="/usr/lib/jvm"
24286   BOOT_JDK_SUFFIX=""
24287   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24288   if test "x$ALL_JDKS_FOUND" != x; then
24289     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24290 
24291   if test "x$BOOT_JDK_FOUND" = xno; then
24292     # Now execute the test
24293 
24294         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24295         if test -d "$BOOT_JDK"; then
24296           BOOT_JDK_FOUND=maybe
24297           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24298 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24299         fi
24300 
24301 
24302     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24303     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24304       # Do we have a bin/java?
24305       if test ! -x "$BOOT_JDK/bin/java"; then
24306         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24307 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24308         BOOT_JDK_FOUND=no
24309       else
24310         # Do we have a bin/javac?
24311         if test ! -x "$BOOT_JDK/bin/javac"; then
24312           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24313 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24314           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24315 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24316           BOOT_JDK_FOUND=no
24317         else
24318           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
24319           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
24320             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
24321 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
24322             BOOT_JDK_FOUND=no
24323           else
24324             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24325             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24326 
24327             # Extra M4 quote needed to protect [] in grep expression.
24328             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
24329             if test "x$FOUND_CORRECT_VERSION" = x; then
24330               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24331 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24332               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
24333 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
24334               BOOT_JDK_FOUND=no
24335             else
24336               # We're done! :-)
24337               BOOT_JDK_FOUND=yes
24338 
24339   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24340 
24341   # Input might be given as Windows format, start by converting to
24342   # unix format.
24343   path="$BOOT_JDK"
24344   new_path=`$CYGPATH -u "$path"`
24345 
24346   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24347   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24348   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24349   # "foo.exe" is OK but "foo" is an error.
24350   #
24351   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24352   # It is also a way to make sure we got the proper file name for the real test later on.
24353   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24354   if test "x$test_shortpath" = x; then
24355     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24356 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24357     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24358   fi
24359 
24360   # Call helper function which possibly converts this using DOS-style short mode.
24361   # If so, the updated path is stored in $new_path.
24362 
24363   input_path="$new_path"
24364   # Check if we need to convert this using DOS-style short mode. If the path
24365   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24366   # take no chances and rewrite it.
24367   # Note: m4 eats our [], so we need to use [ and ] instead.
24368   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24369   if test "x$has_forbidden_chars" != x; then
24370     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24371     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24372     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24373     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24374       # Going to short mode and back again did indeed matter. Since short mode is
24375       # case insensitive, let's make it lowercase to improve readability.
24376       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24377       # Now convert it back to Unix-stile (cygpath)
24378       input_path=`$CYGPATH -u "$shortmode_path"`
24379       new_path="$input_path"
24380     fi
24381   fi
24382 
24383   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24384   if test "x$test_cygdrive_prefix" = x; then
24385     # As a simple fix, exclude /usr/bin since it's not a real path.
24386     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24387       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24388       # a path prefixed by /cygdrive for fixpath to work.
24389       new_path="$CYGWIN_ROOT_PATH$input_path"
24390     fi
24391   fi
24392 
24393 
24394   if test "x$path" != "x$new_path"; then
24395     BOOT_JDK="$new_path"
24396     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24397 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24398   fi
24399 
24400   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24401 
24402   path="$BOOT_JDK"
24403   has_colon=`$ECHO $path | $GREP ^.:`
24404   new_path="$path"
24405   if test "x$has_colon" = x; then
24406     # Not in mixed or Windows style, start by that.
24407     new_path=`cmd //c echo $path`
24408   fi
24409 
24410 
24411   input_path="$new_path"
24412   # Check if we need to convert this using DOS-style short mode. If the path
24413   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24414   # take no chances and rewrite it.
24415   # Note: m4 eats our [], so we need to use [ and ] instead.
24416   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24417   if test "x$has_forbidden_chars" != x; then
24418     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24419     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24420   fi
24421 
24422 
24423   windows_path="$new_path"
24424   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24425     unix_path=`$CYGPATH -u "$windows_path"`
24426     new_path="$unix_path"
24427   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24428     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24429     new_path="$unix_path"
24430   fi
24431 
24432   if test "x$path" != "x$new_path"; then
24433     BOOT_JDK="$new_path"
24434     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24435 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24436   fi
24437 
24438   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24439   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24440 
24441   else
24442     # We're on a posix platform. Hooray! :)
24443     path="$BOOT_JDK"
24444     has_space=`$ECHO "$path" | $GREP " "`
24445     if test "x$has_space" != x; then
24446       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24447 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24448       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24449     fi
24450 
24451     # Use eval to expand a potential ~
24452     eval path="$path"
24453     if test ! -f "$path" && test ! -d "$path"; then
24454       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24455     fi
24456 
24457     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24458   fi
24459 
24460               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24461 $as_echo_n "checking for Boot JDK... " >&6; }
24462               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24463 $as_echo "$BOOT_JDK" >&6; }
24464               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24465 $as_echo_n "checking Boot JDK version... " >&6; }
24466               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24467               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24468 $as_echo "$BOOT_JDK_VERSION" >&6; }
24469             fi # end check jdk version
24470           fi # end check rt.jar
24471         fi # end check javac
24472       fi # end check java
24473     fi # end check boot jdk found
24474   fi
24475 
24476     done
24477   fi
24478 
24479 
24480     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24481     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24482       # Do we have a bin/java?
24483       if test ! -x "$BOOT_JDK/bin/java"; then
24484         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24485 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24486         BOOT_JDK_FOUND=no
24487       else
24488         # Do we have a bin/javac?
24489         if test ! -x "$BOOT_JDK/bin/javac"; then
24490           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24491 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24492           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24493 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24494           BOOT_JDK_FOUND=no
24495         else
24496           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
24497           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
24498             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
24499 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
24500             BOOT_JDK_FOUND=no
24501           else
24502             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24503             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24504 
24505             # Extra M4 quote needed to protect [] in grep expression.
24506             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
24507             if test "x$FOUND_CORRECT_VERSION" = x; then
24508               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24509 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24510               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
24511 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
24512               BOOT_JDK_FOUND=no
24513             else
24514               # We're done! :-)
24515               BOOT_JDK_FOUND=yes
24516 
24517   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24518 
24519   # Input might be given as Windows format, start by converting to
24520   # unix format.
24521   path="$BOOT_JDK"
24522   new_path=`$CYGPATH -u "$path"`
24523 
24524   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24525   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24526   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24527   # "foo.exe" is OK but "foo" is an error.
24528   #
24529   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24530   # It is also a way to make sure we got the proper file name for the real test later on.
24531   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24532   if test "x$test_shortpath" = x; then
24533     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24534 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24535     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24536   fi
24537 
24538   # Call helper function which possibly converts this using DOS-style short mode.
24539   # If so, the updated path is stored in $new_path.
24540 
24541   input_path="$new_path"
24542   # Check if we need to convert this using DOS-style short mode. If the path
24543   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24544   # take no chances and rewrite it.
24545   # Note: m4 eats our [], so we need to use [ and ] instead.
24546   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24547   if test "x$has_forbidden_chars" != x; then
24548     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24549     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24550     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24551     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24552       # Going to short mode and back again did indeed matter. Since short mode is
24553       # case insensitive, let's make it lowercase to improve readability.
24554       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24555       # Now convert it back to Unix-stile (cygpath)
24556       input_path=`$CYGPATH -u "$shortmode_path"`
24557       new_path="$input_path"
24558     fi
24559   fi
24560 
24561   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24562   if test "x$test_cygdrive_prefix" = x; then
24563     # As a simple fix, exclude /usr/bin since it's not a real path.
24564     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24565       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24566       # a path prefixed by /cygdrive for fixpath to work.
24567       new_path="$CYGWIN_ROOT_PATH$input_path"
24568     fi
24569   fi
24570 
24571 
24572   if test "x$path" != "x$new_path"; then
24573     BOOT_JDK="$new_path"
24574     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24575 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24576   fi
24577 
24578   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24579 
24580   path="$BOOT_JDK"
24581   has_colon=`$ECHO $path | $GREP ^.:`
24582   new_path="$path"
24583   if test "x$has_colon" = x; then
24584     # Not in mixed or Windows style, start by that.
24585     new_path=`cmd //c echo $path`
24586   fi
24587 
24588 
24589   input_path="$new_path"
24590   # Check if we need to convert this using DOS-style short mode. If the path
24591   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24592   # take no chances and rewrite it.
24593   # Note: m4 eats our [], so we need to use [ and ] instead.
24594   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24595   if test "x$has_forbidden_chars" != x; then
24596     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24597     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24598   fi
24599 
24600 
24601   windows_path="$new_path"
24602   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24603     unix_path=`$CYGPATH -u "$windows_path"`
24604     new_path="$unix_path"
24605   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24606     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24607     new_path="$unix_path"
24608   fi
24609 
24610   if test "x$path" != "x$new_path"; then
24611     BOOT_JDK="$new_path"
24612     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24613 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24614   fi
24615 
24616   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24617   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24618 
24619   else
24620     # We're on a posix platform. Hooray! :)
24621     path="$BOOT_JDK"
24622     has_space=`$ECHO "$path" | $GREP " "`
24623     if test "x$has_space" != x; then
24624       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24625 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24626       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24627     fi
24628 
24629     # Use eval to expand a potential ~
24630     eval path="$path"
24631     if test ! -f "$path" && test ! -d "$path"; then
24632       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24633     fi
24634 
24635     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24636   fi
24637 
24638               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24639 $as_echo_n "checking for Boot JDK... " >&6; }
24640               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24641 $as_echo "$BOOT_JDK" >&6; }
24642               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24643 $as_echo_n "checking Boot JDK version... " >&6; }
24644               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24645               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24646 $as_echo "$BOOT_JDK_VERSION" >&6; }
24647             fi # end check jdk version
24648           fi # end check rt.jar
24649         fi # end check javac
24650       fi # end check java
24651     fi # end check boot jdk found
24652   fi
24653 
24654   fi
24655 
24656 
24657     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24658     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24659       # Do we have a bin/java?
24660       if test ! -x "$BOOT_JDK/bin/java"; then
24661         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24662 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24663         BOOT_JDK_FOUND=no
24664       else
24665         # Do we have a bin/javac?
24666         if test ! -x "$BOOT_JDK/bin/javac"; then
24667           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24668 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24669           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24670 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24671           BOOT_JDK_FOUND=no
24672         else
24673           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
24674           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
24675             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
24676 $as_echo "$a