1 #!/bin/bash
   2 #
   3 # ##########################################################
   4 # ### THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT. ###
   5 # ##########################################################
   6 #
   7 #! /bin/sh
   8 # Guess values for system-dependent variables and create Makefiles.
   9 # Generated by GNU Autoconf 2.69 for OpenJDK jdk9.
  10 #
  11 # Report bugs to <build-dev@openjdk.java.net>.
  12 #
  13 #
  14 # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
  15 #
  16 #
  17 # This configure script is free software; the Free Software Foundation
  18 # gives unlimited permission to copy, distribute and modify it.
  19 ## -------------------- ##
  20 ## M4sh Initialization. ##
  21 ## -------------------- ##
  22 
  23 # Be more Bourne compatible
  24 DUALCASE=1; export DUALCASE # for MKS sh
  25 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
  26   emulate sh
  27   NULLCMD=:
  28   # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  29   # is contrary to our usage.  Disable this feature.
  30   alias -g '${1+"$@"}'='"$@"'
  31   setopt NO_GLOB_SUBST
  32 else
  33   case `(set -o) 2>/dev/null` in #(
  34   *posix*) :
  35     set -o posix ;; #(
  36   *) :
  37      ;;
  38 esac
  39 fi
  40 
  41 
  42 as_nl='
  43 '
  44 export as_nl
  45 # Printing a long string crashes Solaris 7 /usr/bin/printf.
  46 as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
  47 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
  48 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
  49 # Prefer a ksh shell builtin over an external printf program on Solaris,
  50 # but without wasting forks for bash or zsh.
  51 if test -z "$BASH_VERSION$ZSH_VERSION" \
  52     && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
  53   as_echo='print -r --'
  54   as_echo_n='print -rn --'
  55 elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  56   as_echo='printf %s\n'
  57   as_echo_n='printf %s'
  58 else
  59   if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
  60     as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
  61     as_echo_n='/usr/ucb/echo -n'
  62   else
  63     as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
  64     as_echo_n_body='eval
  65       arg=$1;
  66       case $arg in #(
  67       *"$as_nl"*)
  68         expr "X$arg" : "X\\(.*\\)$as_nl";
  69         arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
  70       esac;
  71       expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
  72     '
  73     export as_echo_n_body
  74     as_echo_n='sh -c $as_echo_n_body as_echo'
  75   fi
  76   export as_echo_body
  77   as_echo='sh -c $as_echo_body as_echo'
  78 fi
  79 
  80 # The user is always right.
  81 if test "${PATH_SEPARATOR+set}" != set; then
  82   PATH_SEPARATOR=:
  83   (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
  84     (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
  85       PATH_SEPARATOR=';'
  86   }
  87 fi
  88 
  89 
  90 # IFS
  91 # We need space, tab and new line, in precisely that order.  Quoting is
  92 # there to prevent editors from complaining about space-tab.
  93 # (If _AS_PATH_WALK were called with IFS unset, it would disable word
  94 # splitting by setting IFS to empty value.)
  95 IFS=" ""        $as_nl"
  96 
  97 # Find who we are.  Look in the path if we contain no directory separator.
  98 as_myself=
  99 case $0 in #((
 100   *[\\/]* ) as_myself=$0 ;;
 101   *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 102 for as_dir in $PATH
 103 do
 104   IFS=$as_save_IFS
 105   test -z "$as_dir" && as_dir=.
 106     test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 107   done
 108 IFS=$as_save_IFS
 109 
 110      ;;
 111 esac
 112 # We did not find ourselves, most probably we were run as `sh COMMAND'
 113 # in which case we are not to be found in the path.
 114 if test "x$as_myself" = x; then
 115   as_myself=$0
 116 fi
 117 if test ! -f "$as_myself"; then
 118   $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
 119   exit 1
 120 fi
 121 
 122 # Unset variables that we do not need and which cause bugs (e.g. in
 123 # pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
 124 # suppresses any "Segmentation fault" message there.  '((' could
 125 # trigger a bug in pdksh 5.2.14.
 126 for as_var in BASH_ENV ENV MAIL MAILPATH
 127 do eval test x\${$as_var+set} = xset \
 128   && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
 129 done
 130 PS1='$ '
 131 PS2='> '
 132 PS4='+ '
 133 
 134 # NLS nuisances.
 135 LC_ALL=C
 136 export LC_ALL
 137 LANGUAGE=C
 138 export LANGUAGE
 139 
 140 # CDPATH.
 141 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
 142 
 143 # Use a proper internal environment variable to ensure we don't fall
 144   # into an infinite loop, continuously re-executing ourselves.
 145   if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
 146     _as_can_reexec=no; export _as_can_reexec;
 147     # We cannot yet assume a decent shell, so we have to provide a
 148 # neutralization value for shells without unset; and this also
 149 # works around shells that cannot unset nonexistent variables.
 150 # Preserve -v and -x to the replacement shell.
 151 BASH_ENV=/dev/null
 152 ENV=/dev/null
 153 (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
 154 case $- in # ((((
 155   *v*x* | *x*v* ) as_opts=-vx ;;
 156   *v* ) as_opts=-v ;;
 157   *x* ) as_opts=-x ;;
 158   * ) as_opts= ;;
 159 esac
 160 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
 161 # Admittedly, this is quite paranoid, since all the known shells bail
 162 # out after a failed `exec'.
 163 $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
 164 as_fn_exit 255
 165   fi
 166   # We don't want this to propagate to other subprocesses.
 167           { _as_can_reexec=; unset _as_can_reexec;}
 168 if test "x$CONFIG_SHELL" = x; then
 169   as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
 170   emulate sh
 171   NULLCMD=:
 172   # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
 173   # is contrary to our usage.  Disable this feature.
 174   alias -g '\${1+\"\$@\"}'='\"\$@\"'
 175   setopt NO_GLOB_SUBST
 176 else
 177   case \`(set -o) 2>/dev/null\` in #(
 178   *posix*) :
 179     set -o posix ;; #(
 180   *) :
 181      ;;
 182 esac
 183 fi
 184 "
 185   as_required="as_fn_return () { (exit \$1); }
 186 as_fn_success () { as_fn_return 0; }
 187 as_fn_failure () { as_fn_return 1; }
 188 as_fn_ret_success () { return 0; }
 189 as_fn_ret_failure () { return 1; }
 190 
 191 exitcode=0
 192 as_fn_success || { exitcode=1; echo as_fn_success failed.; }
 193 as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
 194 as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
 195 as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
 196 if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
 197 
 198 else
 199   exitcode=1; echo positional parameters were not saved.
 200 fi
 201 test x\$exitcode = x0 || exit 1
 202 test -x / || exit 1"
 203   as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
 204   as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
 205   eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
 206   test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
 207 test \$(( 1 + 1 )) = 2 || exit 1"
 208   if (eval "$as_required") 2>/dev/null; then :
 209   as_have_required=yes
 210 else
 211   as_have_required=no
 212 fi
 213   if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
 214 
 215 else
 216   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 217 as_found=false
 218 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 219 do
 220   IFS=$as_save_IFS
 221   test -z "$as_dir" && as_dir=.
 222   as_found=:
 223   case $as_dir in #(
 224          /*)
 225            for as_base in sh bash ksh sh5; do
 226              # Try only shells that exist, to save several forks.
 227              as_shell=$as_dir/$as_base
 228              if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
 229                     { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
 230   CONFIG_SHELL=$as_shell as_have_required=yes
 231                    if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
 232   break 2
 233 fi
 234 fi
 235            done;;
 236        esac
 237   as_found=false
 238 done
 239 $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
 240               { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
 241   CONFIG_SHELL=$SHELL as_have_required=yes
 242 fi; }
 243 IFS=$as_save_IFS
 244 
 245 
 246       if test "x$CONFIG_SHELL" != x; then :
 247   export CONFIG_SHELL
 248              # We cannot yet assume a decent shell, so we have to provide a
 249 # neutralization value for shells without unset; and this also
 250 # works around shells that cannot unset nonexistent variables.
 251 # Preserve -v and -x to the replacement shell.
 252 BASH_ENV=/dev/null
 253 ENV=/dev/null
 254 (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
 255 case $- in # ((((
 256   *v*x* | *x*v* ) as_opts=-vx ;;
 257   *v* ) as_opts=-v ;;
 258   *x* ) as_opts=-x ;;
 259   * ) as_opts= ;;
 260 esac
 261 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
 262 # Admittedly, this is quite paranoid, since all the known shells bail
 263 # out after a failed `exec'.
 264 $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
 265 exit 255
 266 fi
 267 
 268     if test x$as_have_required = xno; then :
 269   $as_echo "$0: This script requires a shell more modern than all"
 270   $as_echo "$0: the shells that I found on your system."
 271   if test x${ZSH_VERSION+set} = xset ; then
 272     $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
 273     $as_echo "$0: be upgraded to zsh 4.3.4 or later."
 274   else
 275     $as_echo "$0: Please tell bug-autoconf@gnu.org and
 276 $0: build-dev@openjdk.java.net about your system, including
 277 $0: any error possibly output before this message. Then
 278 $0: install a modern shell, or manually run the script
 279 $0: under such a shell if you do have one."
 280   fi
 281   exit 1
 282 fi
 283 fi
 284 fi
 285 SHELL=${CONFIG_SHELL-/bin/sh}
 286 export SHELL
 287 # Unset more variables known to interfere with behavior of common tools.
 288 CLICOLOR_FORCE= GREP_OPTIONS=
 289 unset CLICOLOR_FORCE GREP_OPTIONS
 290 
 291 ## --------------------- ##
 292 ## M4sh Shell Functions. ##
 293 ## --------------------- ##
 294 # as_fn_unset VAR
 295 # ---------------
 296 # Portably unset VAR.
 297 as_fn_unset ()
 298 {
 299   { eval $1=; unset $1;}
 300 }
 301 as_unset=as_fn_unset
 302 
 303 # as_fn_set_status STATUS
 304 # -----------------------
 305 # Set $? to STATUS, without forking.
 306 as_fn_set_status ()
 307 {
 308   return $1
 309 } # as_fn_set_status
 310 
 311 # as_fn_exit STATUS
 312 # -----------------
 313 # Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
 314 as_fn_exit ()
 315 {
 316   set +e
 317   as_fn_set_status $1
 318   exit $1
 319 } # as_fn_exit
 320 
 321 # as_fn_mkdir_p
 322 # -------------
 323 # Create "$as_dir" as a directory, including parents if necessary.
 324 as_fn_mkdir_p ()
 325 {
 326 
 327   case $as_dir in #(
 328   -*) as_dir=./$as_dir;;
 329   esac
 330   test -d "$as_dir" || eval $as_mkdir_p || {
 331     as_dirs=
 332     while :; do
 333       case $as_dir in #(
 334       *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
 335       *) as_qdir=$as_dir;;
 336       esac
 337       as_dirs="'$as_qdir' $as_dirs"
 338       as_dir=`$as_dirname -- "$as_dir" ||
 339 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 340          X"$as_dir" : 'X\(//\)[^/]' \| \
 341          X"$as_dir" : 'X\(//\)$' \| \
 342          X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
 343 $as_echo X"$as_dir" |
 344     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
 345             s//\1/
 346             q
 347           }
 348           /^X\(\/\/\)[^/].*/{
 349             s//\1/
 350             q
 351           }
 352           /^X\(\/\/\)$/{
 353             s//\1/
 354             q
 355           }
 356           /^X\(\/\).*/{
 357             s//\1/
 358             q
 359           }
 360           s/.*/./; q'`
 361       test -d "$as_dir" && break
 362     done
 363     test -z "$as_dirs" || eval "mkdir $as_dirs"
 364   } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
 365 
 366 
 367 } # as_fn_mkdir_p
 368 
 369 # as_fn_executable_p FILE
 370 # -----------------------
 371 # Test if FILE is an executable regular file.
 372 as_fn_executable_p ()
 373 {
 374   test -f "$1" && test -x "$1"
 375 } # as_fn_executable_p
 376 # as_fn_append VAR VALUE
 377 # ----------------------
 378 # Append the text in VALUE to the end of the definition contained in VAR. Take
 379 # advantage of any shell optimizations that allow amortized linear growth over
 380 # repeated appends, instead of the typical quadratic growth present in naive
 381 # implementations.
 382 if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
 383   eval 'as_fn_append ()
 384   {
 385     eval $1+=\$2
 386   }'
 387 else
 388   as_fn_append ()
 389   {
 390     eval $1=\$$1\$2
 391   }
 392 fi # as_fn_append
 393 
 394 # as_fn_arith ARG...
 395 # ------------------
 396 # Perform arithmetic evaluation on the ARGs, and store the result in the
 397 # global $as_val. Take advantage of shells that can avoid forks. The arguments
 398 # must be portable across $(()) and expr.
 399 if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
 400   eval 'as_fn_arith ()
 401   {
 402     as_val=$(( $* ))
 403   }'
 404 else
 405   as_fn_arith ()
 406   {
 407     as_val=`expr "$@" || test $? -eq 1`
 408   }
 409 fi # as_fn_arith
 410 
 411 
 412 # as_fn_error STATUS ERROR [LINENO LOG_FD]
 413 # ----------------------------------------
 414 # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
 415 # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
 416 # script with STATUS, using 1 if that was 0.
 417 as_fn_error ()
 418 {
 419   as_status=$1; test $as_status -eq 0 && as_status=1
 420   if test "$4"; then
 421     as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
 422     $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
 423   fi
 424   $as_echo "$as_me: error: $2" >&2
 425   as_fn_exit $as_status
 426 } # as_fn_error
 427 
 428 if expr a : '\(a\)' >/dev/null 2>&1 &&
 429    test "X`expr 00001 : '.*\(...\)'`" = X001; then
 430   as_expr=expr
 431 else
 432   as_expr=false
 433 fi
 434 
 435 if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
 436   as_basename=basename
 437 else
 438   as_basename=false
 439 fi
 440 
 441 if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
 442   as_dirname=dirname
 443 else
 444   as_dirname=false
 445 fi
 446 
 447 as_me=`$as_basename -- "$0" ||
 448 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
 449          X"$0" : 'X\(//\)$' \| \
 450          X"$0" : 'X\(/\)' \| . 2>/dev/null ||
 451 $as_echo X/"$0" |
 452     sed '/^.*\/\([^/][^/]*\)\/*$/{
 453             s//\1/
 454             q
 455           }
 456           /^X\/\(\/\/\)$/{
 457             s//\1/
 458             q
 459           }
 460           /^X\/\(\/\).*/{
 461             s//\1/
 462             q
 463           }
 464           s/.*/./; q'`
 465 
 466 # Avoid depending upon Character Ranges.
 467 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
 468 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 469 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
 470 as_cr_digits='0123456789'
 471 as_cr_alnum=$as_cr_Letters$as_cr_digits
 472 
 473 
 474   as_lineno_1=$LINENO as_lineno_1a=$LINENO
 475   as_lineno_2=$LINENO as_lineno_2a=$LINENO
 476   eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
 477   test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
 478   # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
 479   sed -n '
 480     p
 481     /[$]LINENO/=
 482   ' <$as_myself |
 483     sed '
 484       s/[$]LINENO.*/&-/
 485       t lineno
 486       b
 487       :lineno
 488       N
 489       :loop
 490       s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
 491       t loop
 492       s/-\n.*//
 493     ' >$as_me.lineno &&
 494   chmod +x "$as_me.lineno" ||
 495     { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
 496 
 497   # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
 498   # already done that, so ensure we don't try to do so again and fall
 499   # in an infinite loop.  This has already happened in practice.
 500   _as_can_reexec=no; export _as_can_reexec
 501   # Don't try to exec as it changes $[0], causing all sort of problems
 502   # (the dirname of $[0] is not the place where we might find the
 503   # original and so on.  Autoconf is especially sensitive to this).
 504   . "./$as_me.lineno"
 505   # Exit status is that of the last command.
 506   exit
 507 }
 508 
 509 ECHO_C= ECHO_N= ECHO_T=
 510 case `echo -n x` in #(((((
 511 -n*)
 512   case `echo 'xy\c'` in
 513   *c*) ECHO_T=' ';;     # ECHO_T is single tab character.
 514   xy)  ECHO_C='\c';;
 515   *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
 516        ECHO_T=' ';;
 517   esac;;
 518 *)
 519   ECHO_N='-n';;
 520 esac
 521 
 522 rm -f conf$$ conf$$.exe conf$$.file
 523 if test -d conf$$.dir; then
 524   rm -f conf$$.dir/conf$$.file
 525 else
 526   rm -f conf$$.dir
 527   mkdir conf$$.dir 2>/dev/null
 528 fi
 529 if (echo >conf$$.file) 2>/dev/null; then
 530   if ln -s conf$$.file conf$$ 2>/dev/null; then
 531     as_ln_s='ln -s'
 532     # ... but there are two gotchas:
 533     # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
 534     # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
 535     # In both cases, we have to default to `cp -pR'.
 536     ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
 537       as_ln_s='cp -pR'
 538   elif ln conf$$.file conf$$ 2>/dev/null; then
 539     as_ln_s=ln
 540   else
 541     as_ln_s='cp -pR'
 542   fi
 543 else
 544   as_ln_s='cp -pR'
 545 fi
 546 rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
 547 rmdir conf$$.dir 2>/dev/null
 548 
 549 if mkdir -p . 2>/dev/null; then
 550   as_mkdir_p='mkdir -p "$as_dir"'
 551 else
 552   test -d ./-p && rmdir ./-p
 553   as_mkdir_p=false
 554 fi
 555 
 556 as_test_x='test -x'
 557 as_executable_p=as_fn_executable_p
 558 
 559 # Sed expression to map a string onto a valid CPP name.
 560 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 561 
 562 # Sed expression to map a string onto a valid variable name.
 563 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 564 
 565 
 566 test -n "$DJDIR" || exec 7<&0 </dev/null
 567 exec 6>&1
 568 
 569 # Name of the host.
 570 # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
 571 # so uname gets run too.
 572 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 573 
 574 #
 575 # Initializations.
 576 #
 577 ac_default_prefix=/usr/local
 578 ac_clean_files=
 579 ac_config_libobj_dir=.
 580 LIBOBJS=
 581 cross_compiling=no
 582 subdirs=
 583 MFLAGS=
 584 MAKEFLAGS=
 585 
 586 # Identity of this package.
 587 PACKAGE_NAME='OpenJDK'
 588 PACKAGE_TARNAME='openjdk'
 589 PACKAGE_VERSION='jdk9'
 590 PACKAGE_STRING='OpenJDK jdk9'
 591 PACKAGE_BUGREPORT='build-dev@openjdk.java.net'
 592 PACKAGE_URL='http://openjdk.java.net'
 593 
 594 # Factoring default headers for most tests.
 595 ac_includes_default="\
 596 #include <stdio.h>
 597 #ifdef HAVE_SYS_TYPES_H
 598 # include <sys/types.h>
 599 #endif
 600 #ifdef HAVE_SYS_STAT_H
 601 # include <sys/stat.h>
 602 #endif
 603 #ifdef STDC_HEADERS
 604 # include <stdlib.h>
 605 # include <stddef.h>
 606 #else
 607 # ifdef HAVE_STDLIB_H
 608 #  include <stdlib.h>
 609 # endif
 610 #endif
 611 #ifdef HAVE_STRING_H
 612 # if !defined STDC_HEADERS && defined HAVE_MEMORY_H
 613 #  include <memory.h>
 614 # endif
 615 # include <string.h>
 616 #endif
 617 #ifdef HAVE_STRINGS_H
 618 # include <strings.h>
 619 #endif
 620 #ifdef HAVE_INTTYPES_H
 621 # include <inttypes.h>
 622 #endif
 623 #ifdef HAVE_STDINT_H
 624 # include <stdint.h>
 625 #endif
 626 #ifdef HAVE_UNISTD_H
 627 # include <unistd.h>
 628 #endif"
 629 
 630 ac_subst_vars='LTLIBOBJS
 631 LIBOBJS
 632 CCACHE
 633 USE_PRECOMPILED_HEADER
 634 SJAVAC_SERVER_DIR
 635 ENABLE_SJAVAC
 636 SJAVAC_SERVER_JAVA
 637 JOBS
 638 MEMORY_SIZE
 639 NUM_CORES
 640 ENABLE_INTREE_EC
 641 SALIB_NAME
 642 HOTSPOT_MAKE_ARGS
 643 MSVCR_DLL
 644 LIBCXX
 645 LLVM_LIBS
 646 LLVM_LDFLAGS
 647 LLVM_CFLAGS
 648 LLVM_CONFIG
 649 LIBFFI_LIBS
 650 LIBFFI_CFLAGS
 651 STATIC_CXX_SETTING
 652 LIBDL
 653 LIBM
 654 LIBZIP_CAN_USE_MMAP
 655 USE_EXTERNAL_LIBZ
 656 USE_EXTERNAL_LIBPNG
 657 PNG_LIBS
 658 PNG_CFLAGS
 659 USE_EXTERNAL_LCMS
 660 LCMS_LIBS
 661 LCMS_CFLAGS
 662 USE_EXTERNAL_LIBGIF
 663 USE_EXTERNAL_LIBJPEG
 664 ALSA_LIBS
 665 ALSA_CFLAGS
 666 FREETYPE_BUNDLE_LIB_PATH
 667 FREETYPE_LIBS
 668 FREETYPE_CFLAGS
 669 CUPS_CFLAGS
 670 X_EXTRA_LIBS
 671 X_LIBS
 672 X_PRE_LIBS
 673 X_CFLAGS
 674 XMKMF
 675 FIXPATH
 676 ZIP_DEBUGINFO_FILES
 677 ENABLE_DEBUG_SYMBOLS
 678 CFLAGS_WARNINGS_ARE_ERRORS
 679 COMPILER_SUPPORTS_TARGET_BITS_FLAG
 680 ZERO_ARCHFLAG
 681 LDFLAGS_CXX_JDK
 682 LDFLAGS_JDKEXE_SUFFIX
 683 LDFLAGS_JDKLIB_SUFFIX
 684 LDFLAGS_JDKEXE
 685 LDFLAGS_JDKLIB
 686 CXXFLAGS_JDKEXE
 687 CXXFLAGS_JDKLIB
 688 CFLAGS_JDKEXE
 689 CFLAGS_JDKLIB
 690 MACOSX_VERSION_MIN
 691 LEGACY_EXTRA_LDFLAGS
 692 LEGACY_EXTRA_CXXFLAGS
 693 LEGACY_EXTRA_CFLAGS
 694 CXX_O_FLAG_NONE
 695 CXX_O_FLAG_NORM
 696 CXX_O_FLAG_HI
 697 CXX_O_FLAG_HIGHEST
 698 C_O_FLAG_NONE
 699 C_O_FLAG_NORM
 700 C_O_FLAG_HI
 701 C_O_FLAG_HIGHEST
 702 CXXFLAGS_DEBUG_SYMBOLS
 703 CFLAGS_DEBUG_SYMBOLS
 704 CXX_FLAG_DEPS
 705 C_FLAG_DEPS
 706 SET_SHARED_LIBRARY_MAPFILE
 707 SET_SHARED_LIBRARY_NAME
 708 SET_SHARED_LIBRARY_ORIGIN
 709 SET_EXECUTABLE_ORIGIN
 710 SHARED_LIBRARY_FLAGS
 711 CXX_FLAG_REORDER
 712 C_FLAG_REORDER
 713 SYSROOT_LDFLAGS
 714 SYSROOT_CFLAGS
 715 RC_FLAGS
 716 AR_OUT_OPTION
 717 LD_OUT_OPTION
 718 EXE_OUT_OPTION
 719 CC_OUT_OPTION
 720 POST_MCS_CMD
 721 POST_STRIP_CMD
 722 ARFLAGS
 723 COMPILER_TARGET_BITS_FLAG
 724 JT_HOME
 725 JTREGEXE
 726 USING_BROKEN_SUSE_LD
 727 PACKAGE_PATH
 728 LDEXECXX
 729 LDEXE
 730 USE_CLANG
 731 HOTSPOT_LD
 732 HOTSPOT_CXX
 733 HOTSPOT_RC
 734 HOTSPOT_MT
 735 BUILD_LD
 736 BUILD_CXX
 737 BUILD_CC
 738 ac_ct_OBJDUMP
 739 OBJDUMP
 740 ac_ct_OBJCOPY
 741 OBJCOPY
 742 ac_ct_NM
 743 ac_ct_STRIP
 744 MCS
 745 GNM
 746 NM
 747 STRIP
 748 DUMPBIN
 749 RC
 750 MT
 751 LIPO
 752 ac_ct_OBJC
 753 OBJCFLAGS
 754 OBJC
 755 ac_ct_AR
 756 AR
 757 AS
 758 LDCXX
 759 LD
 760 CXXCPP
 761 CPP
 762 ac_ct_CXX
 763 CXXFLAGS
 764 CXX
 765 ac_ct_PROPER_COMPILER_CXX
 766 PROPER_COMPILER_CXX
 767 TOOLCHAIN_PATH_CXX
 768 POTENTIAL_CXX
 769 OBJEXT
 770 EXEEXT
 771 ac_ct_CC
 772 CPPFLAGS
 773 LDFLAGS
 774 CFLAGS
 775 CC
 776 ac_ct_PROPER_COMPILER_CC
 777 PROPER_COMPILER_CC
 778 TOOLCHAIN_PATH_CC
 779 POTENTIAL_CC
 780 VS_LIB
 781 VS_INCLUDE
 782 VS_PATH
 783 CYGWIN_LINK
 784 EXE_SUFFIX
 785 OBJ_SUFFIX
 786 STATIC_LIBRARY
 787 SHARED_LIBRARY
 788 STATIC_LIBRARY_SUFFIX
 789 SHARED_LIBRARY_SUFFIX
 790 LIBRARY_PREFIX
 791 TOOLCHAIN_TYPE
 792 BUILD_HOTSPOT
 793 HOTSPOT_DIST
 794 BUILD_OUTPUT
 795 OVERRIDE_SRC_ROOT
 796 ADD_SRC_ROOT
 797 JDK_TOPDIR
 798 NASHORN_TOPDIR
 799 HOTSPOT_TOPDIR
 800 JAXWS_TOPDIR
 801 JAXP_TOPDIR
 802 CORBA_TOPDIR
 803 LANGTOOLS_TOPDIR
 804 JAVA_FLAGS_SMALL
 805 JAVA_FLAGS_BIG
 806 JAVA_FLAGS
 807 JAVAC_FLAGS
 808 BOOT_JDK_SOURCETARGET
 809 JARSIGNER
 810 NATIVE2ASCII
 811 JAR
 812 JAVAH
 813 JAVAC
 814 JAVA
 815 BOOT_JDK
 816 BOOT_TOOLSJAR
 817 BOOT_RTJAR
 818 JAVA_CHECK
 819 JAVAC_CHECK
 820 COOKED_BUILD_NUMBER
 821 JDK_VERSION
 822 COPYRIGHT_YEAR
 823 MACOSX_BUNDLE_ID_BASE
 824 MACOSX_BUNDLE_NAME_BASE
 825 COMPANY_NAME
 826 JDK_RC_PLATFORM_NAME
 827 PRODUCT_SUFFIX
 828 PRODUCT_NAME
 829 LAUNCHER_NAME
 830 MILESTONE
 831 JDK_BUILD_NUMBER
 832 JDK_UPDATE_VERSION
 833 JDK_MICRO_VERSION
 834 JDK_MINOR_VERSION
 835 JDK_MAJOR_VERSION
 836 USER_RELEASE_SUFFIX
 837 COMPRESS_JARS
 838 RMICONNECTOR_IIOP
 839 UNLIMITED_CRYPTO
 840 CACERTS_FILE
 841 TEST_IN_BUILD
 842 BUILD_HEADLESS
 843 SUPPORT_HEADFUL
 844 SUPPORT_HEADLESS
 845 BDEPS_FTP
 846 BDEPS_UNZIP
 847 OS_VERSION_MICRO
 848 OS_VERSION_MINOR
 849 OS_VERSION_MAJOR
 850 PKG_CONFIG
 851 CODESIGN
 852 XATTR
 853 DSYMUTIL
 854 IS_GNU_TIME
 855 TIME
 856 STAT
 857 HG
 858 READELF
 859 OTOOL
 860 LDD
 861 ZIP
 862 UNZIP
 863 FIND_DELETE
 864 MAKE
 865 CHECK_TOOLSDIR_MAKE
 866 CHECK_TOOLSDIR_GMAKE
 867 CHECK_MAKE
 868 CHECK_GMAKE
 869 PKGHANDLER
 870 OUTPUT_ROOT
 871 CONF_NAME
 872 SPEC
 873 BUILD_VARIANT_RELEASE
 874 DEBUG_CLASSFILES
 875 FASTDEBUG
 876 VARIANT
 877 DEBUG_LEVEL
 878 MACOSX_UNIVERSAL
 879 INCLUDE_SA
 880 JVM_VARIANT_CORE
 881 JVM_VARIANT_ZEROSHARK
 882 JVM_VARIANT_ZERO
 883 JVM_VARIANT_KERNEL
 884 JVM_VARIANT_MINIMAL1
 885 JVM_VARIANT_CLIENT
 886 JVM_VARIANT_SERVER
 887 JVM_VARIANTS
 888 JVM_INTERPRETER
 889 JDK_VARIANT
 890 SET_OPENJDK
 891 BUILD_LOG_WRAPPER
 892 BUILD_LOG_PREVIOUS
 893 BUILD_LOG
 894 TOPDIR
 895 PATH_SEP
 896 ZERO_ARCHDEF
 897 DEFINE_CROSS_COMPILE_ARCH
 898 LP64
 899 OPENJDK_TARGET_OS_EXPORT_DIR
 900 OPENJDK_TARGET_OS_API_DIR
 901 OPENJDK_TARGET_CPU_JLI_CFLAGS
 902 OPENJDK_TARGET_CPU_OSARCH
 903 OPENJDK_TARGET_CPU_ISADIR
 904 OPENJDK_TARGET_CPU_LIBDIR
 905 OPENJDK_TARGET_CPU_LEGACY_LIB
 906 OPENJDK_TARGET_CPU_LEGACY
 907 REQUIRED_OS_VERSION
 908 REQUIRED_OS_NAME
 909 COMPILE_TYPE
 910 OPENJDK_TARGET_CPU_ENDIAN
 911 OPENJDK_TARGET_CPU_BITS
 912 OPENJDK_TARGET_CPU_ARCH
 913 OPENJDK_TARGET_CPU
 914 OPENJDK_TARGET_OS_API
 915 OPENJDK_TARGET_OS
 916 OPENJDK_BUILD_CPU_ENDIAN
 917 OPENJDK_BUILD_CPU_BITS
 918 OPENJDK_BUILD_CPU_ARCH
 919 OPENJDK_BUILD_CPU
 920 OPENJDK_BUILD_OS_API
 921 OPENJDK_BUILD_OS
 922 OPENJDK_BUILD_AUTOCONF_NAME
 923 OPENJDK_TARGET_AUTOCONF_NAME
 924 target_os
 925 target_vendor
 926 target_cpu
 927 target
 928 host_os
 929 host_vendor
 930 host_cpu
 931 host
 932 build_os
 933 build_vendor
 934 build_cpu
 935 build
 936 SETFILE
 937 DF
 938 READLINK
 939 CYGPATH
 940 SED
 941 FGREP
 942 EGREP
 943 GREP
 944 AWK
 945 XARGS
 946 WHICH
 947 WC
 948 UNIQ
 949 UNAME
 950 TR
 951 TOUCH
 952 TEE
 953 TAR
 954 TAIL
 955 SORT
 956 SH
 957 RM
 958 PRINTF
 959 NAWK
 960 MV
 961 MKTEMP
 962 MKDIR
 963 LS
 964 LN
 965 HEAD
 966 FIND
 967 FILE
 968 EXPR
 969 ECHO
 970 DIRNAME
 971 DIFF
 972 DATE
 973 CUT
 974 CPIO
 975 CP
 976 COMM
 977 CMP
 978 CHMOD
 979 CAT
 980 BASH
 981 BASENAME
 982 DATE_WHEN_CONFIGURED
 983 CONFIGURE_COMMAND_LINE
 984 target_alias
 985 host_alias
 986 build_alias
 987 LIBS
 988 ECHO_T
 989 ECHO_N
 990 ECHO_C
 991 DEFS
 992 mandir
 993 localedir
 994 libdir
 995 psdir
 996 pdfdir
 997 dvidir
 998 htmldir
 999 infodir
1000 docdir
1001 oldincludedir
1002 includedir
1003 localstatedir
1004 sharedstatedir
1005 sysconfdir
1006 datadir
1007 datarootdir
1008 libexecdir
1009 sbindir
1010 bindir
1011 program_transform_name
1012 prefix
1013 exec_prefix
1014 PACKAGE_URL
1015 PACKAGE_BUGREPORT
1016 PACKAGE_STRING
1017 PACKAGE_VERSION
1018 PACKAGE_TARNAME
1019 PACKAGE_NAME
1020 PATH_SEPARATOR
1021 SHELL'
1022 ac_subst_files=''
1023 ac_user_opts='
1024 enable_option_checking
1025 with_target_bits
1026 enable_openjdk_only
1027 with_custom_make_dir
1028 with_jdk_variant
1029 with_jvm_interpreter
1030 with_jvm_variants
1031 enable_debug
1032 with_debug_level
1033 with_devkit
1034 with_sys_root
1035 with_sysroot
1036 with_tools_dir
1037 with_toolchain_path
1038 with_extra_path
1039 with_conf_name
1040 with_builddeps_conf
1041 with_builddeps_server
1042 with_builddeps_dir
1043 with_builddeps_group
1044 enable_headful
1045 enable_hotspot_test_in_build
1046 with_cacerts_file
1047 enable_unlimited_crypto
1048 enable_rmiconnector_iiop
1049 with_milestone
1050 with_update_version
1051 with_user_release_suffix
1052 with_build_number
1053 with_boot_jdk
1054 with_boot_jdk_jvmargs
1055 with_add_source_root
1056 with_override_source_root
1057 with_adds_and_overrides
1058 with_override_langtools
1059 with_override_corba
1060 with_override_jaxp
1061 with_override_jaxws
1062 with_override_hotspot
1063 with_override_nashorn
1064 with_override_jdk
1065 with_import_hotspot
1066 with_toolchain_type
1067 with_jtreg
1068 with_extra_cflags
1069 with_extra_cxxflags
1070 with_extra_ldflags
1071 enable_debug_symbols
1072 enable_zip_debug_info
1073 enable_macosx_runtime_support
1074 with_x
1075 with_cups
1076 with_cups_include
1077 with_freetype
1078 with_freetype_include
1079 with_freetype_lib
1080 enable_freetype_bundling
1081 with_alsa
1082 with_alsa_include
1083 with_alsa_lib
1084 with_libjpeg
1085 with_giflib
1086 with_lcms
1087 with_libpng
1088 with_zlib
1089 with_stdc__lib
1090 with_msvcr_dll
1091 with_dxsdk
1092 with_dxsdk_lib
1093 with_dxsdk_include
1094 with_num_cores
1095 with_memory_size
1096 with_jobs
1097 with_sjavac_server_java
1098 enable_sjavac
1099 enable_precompiled_headers
1100 enable_ccache
1101 with_ccache_dir
1102 '
1103       ac_precious_vars='build_alias
1104 host_alias
1105 target_alias
1106 BASENAME
1107 BASH
1108 CAT
1109 CHMOD
1110 CMP
1111 COMM
1112 CP
1113 CPIO
1114 CUT
1115 DATE
1116 DIFF
1117 DIRNAME
1118 ECHO
1119 EXPR
1120 FILE
1121 FIND
1122 HEAD
1123 LN
1124 LS
1125 MKDIR
1126 MKTEMP
1127 MV
1128 NAWK
1129 PRINTF
1130 RM
1131 SH
1132 SORT
1133 TAIL
1134 TAR
1135 TEE
1136 TOUCH
1137 TR
1138 UNAME
1139 UNIQ
1140 WC
1141 WHICH
1142 XARGS
1143 AWK
1144 GREP
1145 EGREP
1146 FGREP
1147 SED
1148 CYGPATH
1149 READLINK
1150 DF
1151 SETFILE
1152 UNZIP
1153 ZIP
1154 LDD
1155 OTOOL
1156 READELF
1157 HG
1158 STAT
1159 TIME
1160 DSYMUTIL
1161 XATTR
1162 CODESIGN
1163 PKG_CONFIG
1164 JAVA
1165 JAVAC
1166 JAVAH
1167 JAR
1168 NATIVE2ASCII
1169 JARSIGNER
1170 CC
1171 CFLAGS
1172 LDFLAGS
1173 LIBS
1174 CPPFLAGS
1175 CXX
1176 CXXFLAGS
1177 CCC
1178 CPP
1179 CXXCPP
1180 AS
1181 AR
1182 OBJC
1183 OBJCFLAGS
1184 LIPO
1185 STRIP
1186 NM
1187 GNM
1188 MCS
1189 OBJCOPY
1190 OBJDUMP
1191 BUILD_CC
1192 BUILD_CXX
1193 BUILD_LD
1194 JTREGEXE
1195 XMKMF
1196 FREETYPE_CFLAGS
1197 FREETYPE_LIBS
1198 ALSA_CFLAGS
1199 ALSA_LIBS
1200 LCMS_CFLAGS
1201 LCMS_LIBS
1202 PNG_CFLAGS
1203 PNG_LIBS
1204 LIBFFI_CFLAGS
1205 LIBFFI_LIBS
1206 CCACHE'
1207 
1208 
1209 # Initialize some variables set by options.
1210 ac_init_help=
1211 ac_init_version=false
1212 ac_unrecognized_opts=
1213 ac_unrecognized_sep=
1214 # The variables have the same names as the options, with
1215 # dashes changed to underlines.
1216 cache_file=/dev/null
1217 exec_prefix=NONE
1218 no_create=
1219 no_recursion=
1220 prefix=NONE
1221 program_prefix=NONE
1222 program_suffix=NONE
1223 program_transform_name=s,x,x,
1224 silent=
1225 site=
1226 srcdir=
1227 verbose=
1228 x_includes=NONE
1229 x_libraries=NONE
1230 
1231 # Installation directory options.
1232 # These are left unexpanded so users can "make install exec_prefix=/foo"
1233 # and all the variables that are supposed to be based on exec_prefix
1234 # by default will actually change.
1235 # Use braces instead of parens because sh, perl, etc. also accept them.
1236 # (The list follows the same order as the GNU Coding Standards.)
1237 bindir='${exec_prefix}/bin'
1238 sbindir='${exec_prefix}/sbin'
1239 libexecdir='${exec_prefix}/libexec'
1240 datarootdir='${prefix}/share'
1241 datadir='${datarootdir}'
1242 sysconfdir='${prefix}/etc'
1243 sharedstatedir='${prefix}/com'
1244 localstatedir='${prefix}/var'
1245 includedir='${prefix}/include'
1246 oldincludedir='/usr/include'
1247 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
1248 infodir='${datarootdir}/info'
1249 htmldir='${docdir}'
1250 dvidir='${docdir}'
1251 pdfdir='${docdir}'
1252 psdir='${docdir}'
1253 libdir='${exec_prefix}/lib'
1254 localedir='${datarootdir}/locale'
1255 mandir='${datarootdir}/man'
1256 
1257 ac_prev=
1258 ac_dashdash=
1259 for ac_option
1260 do
1261   # If the previous option needs an argument, assign it.
1262   if test -n "$ac_prev"; then
1263     eval $ac_prev=\$ac_option
1264     ac_prev=
1265     continue
1266   fi
1267 
1268   case $ac_option in
1269   *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
1270   *=)   ac_optarg= ;;
1271   *)    ac_optarg=yes ;;
1272   esac
1273 
1274   # Accept the important Cygnus configure options, so we can diagnose typos.
1275 
1276   case $ac_dashdash$ac_option in
1277   --)
1278     ac_dashdash=yes ;;
1279 
1280   -bindir | --bindir | --bindi | --bind | --bin | --bi)
1281     ac_prev=bindir ;;
1282   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
1283     bindir=$ac_optarg ;;
1284 
1285   -build | --build | --buil | --bui | --bu)
1286     ac_prev=build_alias ;;
1287   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
1288     build_alias=$ac_optarg ;;
1289 
1290   -cache-file | --cache-file | --cache-fil | --cache-fi \
1291   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
1292     ac_prev=cache_file ;;
1293   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
1294   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
1295     cache_file=$ac_optarg ;;
1296 
1297   --config-cache | -C)
1298     cache_file=config.cache ;;
1299 
1300   -datadir | --datadir | --datadi | --datad)
1301     ac_prev=datadir ;;
1302   -datadir=* | --datadir=* | --datadi=* | --datad=*)
1303     datadir=$ac_optarg ;;
1304 
1305   -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
1306   | --dataroo | --dataro | --datar)
1307     ac_prev=datarootdir ;;
1308   -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
1309   | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
1310     datarootdir=$ac_optarg ;;
1311 
1312   -disable-* | --disable-*)
1313     ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
1314     # Reject names that are not valid shell variable names.
1315     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1316       as_fn_error $? "invalid feature name: $ac_useropt"
1317     ac_useropt_orig=$ac_useropt
1318     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1319     case $ac_user_opts in
1320       *"
1321 "enable_$ac_useropt"
1322 "*) ;;
1323       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
1324          ac_unrecognized_sep=', ';;
1325     esac
1326     eval enable_$ac_useropt=no ;;
1327 
1328   -docdir | --docdir | --docdi | --doc | --do)
1329     ac_prev=docdir ;;
1330   -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
1331     docdir=$ac_optarg ;;
1332 
1333   -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
1334     ac_prev=dvidir ;;
1335   -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
1336     dvidir=$ac_optarg ;;
1337 
1338   -enable-* | --enable-*)
1339     ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
1340     # Reject names that are not valid shell variable names.
1341     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1342       as_fn_error $? "invalid feature name: $ac_useropt"
1343     ac_useropt_orig=$ac_useropt
1344     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1345     case $ac_user_opts in
1346       *"
1347 "enable_$ac_useropt"
1348 "*) ;;
1349       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
1350          ac_unrecognized_sep=', ';;
1351     esac
1352     eval enable_$ac_useropt=\$ac_optarg ;;
1353 
1354   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
1355   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
1356   | --exec | --exe | --ex)
1357     ac_prev=exec_prefix ;;
1358   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
1359   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
1360   | --exec=* | --exe=* | --ex=*)
1361     exec_prefix=$ac_optarg ;;
1362 
1363   -gas | --gas | --ga | --g)
1364     # Obsolete; use --with-gas.
1365     with_gas=yes ;;
1366 
1367   -help | --help | --hel | --he | -h)
1368     ac_init_help=long ;;
1369   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
1370     ac_init_help=recursive ;;
1371   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
1372     ac_init_help=short ;;
1373 
1374   -host | --host | --hos | --ho)
1375     ac_prev=host_alias ;;
1376   -host=* | --host=* | --hos=* | --ho=*)
1377     host_alias=$ac_optarg ;;
1378 
1379   -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
1380     ac_prev=htmldir ;;
1381   -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
1382   | --ht=*)
1383     htmldir=$ac_optarg ;;
1384 
1385   -includedir | --includedir | --includedi | --included | --include \
1386   | --includ | --inclu | --incl | --inc)
1387     ac_prev=includedir ;;
1388   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
1389   | --includ=* | --inclu=* | --incl=* | --inc=*)
1390     includedir=$ac_optarg ;;
1391 
1392   -infodir | --infodir | --infodi | --infod | --info | --inf)
1393     ac_prev=infodir ;;
1394   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
1395     infodir=$ac_optarg ;;
1396 
1397   -libdir | --libdir | --libdi | --libd)
1398     ac_prev=libdir ;;
1399   -libdir=* | --libdir=* | --libdi=* | --libd=*)
1400     libdir=$ac_optarg ;;
1401 
1402   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
1403   | --libexe | --libex | --libe)
1404     ac_prev=libexecdir ;;
1405   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
1406   | --libexe=* | --libex=* | --libe=*)
1407     libexecdir=$ac_optarg ;;
1408 
1409   -localedir | --localedir | --localedi | --localed | --locale)
1410     ac_prev=localedir ;;
1411   -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
1412     localedir=$ac_optarg ;;
1413 
1414   -localstatedir | --localstatedir | --localstatedi | --localstated \
1415   | --localstate | --localstat | --localsta | --localst | --locals)
1416     ac_prev=localstatedir ;;
1417   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
1418   | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
1419     localstatedir=$ac_optarg ;;
1420 
1421   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
1422     ac_prev=mandir ;;
1423   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
1424     mandir=$ac_optarg ;;
1425 
1426   -nfp | --nfp | --nf)
1427     # Obsolete; use --without-fp.
1428     with_fp=no ;;
1429 
1430   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
1431   | --no-cr | --no-c | -n)
1432     no_create=yes ;;
1433 
1434   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
1435   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
1436     no_recursion=yes ;;
1437 
1438   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
1439   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
1440   | --oldin | --oldi | --old | --ol | --o)
1441     ac_prev=oldincludedir ;;
1442   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
1443   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
1444   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
1445     oldincludedir=$ac_optarg ;;
1446 
1447   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
1448     ac_prev=prefix ;;
1449   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
1450     prefix=$ac_optarg ;;
1451 
1452   -program-prefix | --program-prefix | --program-prefi | --program-pref \
1453   | --program-pre | --program-pr | --program-p)
1454     ac_prev=program_prefix ;;
1455   -program-prefix=* | --program-prefix=* | --program-prefi=* \
1456   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
1457     program_prefix=$ac_optarg ;;
1458 
1459   -program-suffix | --program-suffix | --program-suffi | --program-suff \
1460   | --program-suf | --program-su | --program-s)
1461     ac_prev=program_suffix ;;
1462   -program-suffix=* | --program-suffix=* | --program-suffi=* \
1463   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
1464     program_suffix=$ac_optarg ;;
1465 
1466   -program-transform-name | --program-transform-name \
1467   | --program-transform-nam | --program-transform-na \
1468   | --program-transform-n | --program-transform- \
1469   | --program-transform | --program-transfor \
1470   | --program-transfo | --program-transf \
1471   | --program-trans | --program-tran \
1472   | --progr-tra | --program-tr | --program-t)
1473     ac_prev=program_transform_name ;;
1474   -program-transform-name=* | --program-transform-name=* \
1475   | --program-transform-nam=* | --program-transform-na=* \
1476   | --program-transform-n=* | --program-transform-=* \
1477   | --program-transform=* | --program-transfor=* \
1478   | --program-transfo=* | --program-transf=* \
1479   | --program-trans=* | --program-tran=* \
1480   | --progr-tra=* | --program-tr=* | --program-t=*)
1481     program_transform_name=$ac_optarg ;;
1482 
1483   -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
1484     ac_prev=pdfdir ;;
1485   -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
1486     pdfdir=$ac_optarg ;;
1487 
1488   -psdir | --psdir | --psdi | --psd | --ps)
1489     ac_prev=psdir ;;
1490   -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
1491     psdir=$ac_optarg ;;
1492 
1493   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1494   | -silent | --silent | --silen | --sile | --sil)
1495     silent=yes ;;
1496 
1497   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
1498     ac_prev=sbindir ;;
1499   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
1500   | --sbi=* | --sb=*)
1501     sbindir=$ac_optarg ;;
1502 
1503   -sharedstatedir | --sharedstatedir | --sharedstatedi \
1504   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
1505   | --sharedst | --shareds | --shared | --share | --shar \
1506   | --sha | --sh)
1507     ac_prev=sharedstatedir ;;
1508   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
1509   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
1510   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
1511   | --sha=* | --sh=*)
1512     sharedstatedir=$ac_optarg ;;
1513 
1514   -site | --site | --sit)
1515     ac_prev=site ;;
1516   -site=* | --site=* | --sit=*)
1517     site=$ac_optarg ;;
1518 
1519   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
1520     ac_prev=srcdir ;;
1521   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
1522     srcdir=$ac_optarg ;;
1523 
1524   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
1525   | --syscon | --sysco | --sysc | --sys | --sy)
1526     ac_prev=sysconfdir ;;
1527   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
1528   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
1529     sysconfdir=$ac_optarg ;;
1530 
1531   -target | --target | --targe | --targ | --tar | --ta | --t)
1532     ac_prev=target_alias ;;
1533   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
1534     target_alias=$ac_optarg ;;
1535 
1536   -v | -verbose | --verbose | --verbos | --verbo | --verb)
1537     verbose=yes ;;
1538 
1539   -version | --version | --versio | --versi | --vers | -V)
1540     ac_init_version=: ;;
1541 
1542   -with-* | --with-*)
1543     ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1544     # Reject names that are not valid shell variable names.
1545     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1546       as_fn_error $? "invalid package name: $ac_useropt"
1547     ac_useropt_orig=$ac_useropt
1548     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1549     case $ac_user_opts in
1550       *"
1551 "with_$ac_useropt"
1552 "*) ;;
1553       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
1554          ac_unrecognized_sep=', ';;
1555     esac
1556     eval with_$ac_useropt=\$ac_optarg ;;
1557 
1558   -without-* | --without-*)
1559     ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1560     # Reject names that are not valid shell variable names.
1561     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1562       as_fn_error $? "invalid package name: $ac_useropt"
1563     ac_useropt_orig=$ac_useropt
1564     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1565     case $ac_user_opts in
1566       *"
1567 "with_$ac_useropt"
1568 "*) ;;
1569       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
1570          ac_unrecognized_sep=', ';;
1571     esac
1572     eval with_$ac_useropt=no ;;
1573 
1574   --x)
1575     # Obsolete; use --with-x.
1576     with_x=yes ;;
1577 
1578   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
1579   | --x-incl | --x-inc | --x-in | --x-i)
1580     ac_prev=x_includes ;;
1581   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
1582   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
1583     x_includes=$ac_optarg ;;
1584 
1585   -x-libraries | --x-libraries | --x-librarie | --x-librari \
1586   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
1587     ac_prev=x_libraries ;;
1588   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
1589   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1590     x_libraries=$ac_optarg ;;
1591 
1592   -*) as_fn_error $? "unrecognized option: \`$ac_option'
1593 Try \`$0 --help' for more information"
1594     ;;
1595 
1596   *=*)
1597     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1598     # Reject names that are not valid shell variable names.
1599     case $ac_envvar in #(
1600       '' | [0-9]* | *[!_$as_cr_alnum]* )
1601       as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1602     esac
1603     eval $ac_envvar=\$ac_optarg
1604     export $ac_envvar ;;
1605 
1606   *)
1607     # FIXME: should be removed in autoconf 3.0.
1608     $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1609     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1610       $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1611     : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1612     ;;
1613 
1614   esac
1615 done
1616 
1617 if test -n "$ac_prev"; then
1618   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1619   as_fn_error $? "missing argument to $ac_option"
1620 fi
1621 
1622 if test -n "$ac_unrecognized_opts"; then
1623   case $enable_option_checking in
1624     no) ;;
1625     fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1626     *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1627   esac
1628 fi
1629 
1630 # Check all directory arguments for consistency.
1631 for ac_var in   exec_prefix prefix bindir sbindir libexecdir datarootdir \
1632                 datadir sysconfdir sharedstatedir localstatedir includedir \
1633                 oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
1634                 libdir localedir mandir
1635 do
1636   eval ac_val=\$$ac_var
1637   # Remove trailing slashes.
1638   case $ac_val in
1639     */ )
1640       ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
1641       eval $ac_var=\$ac_val;;
1642   esac
1643   # Be sure to have absolute directory names.
1644   case $ac_val in
1645     [\\/$]* | ?:[\\/]* )  continue;;
1646     NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1647   esac
1648   as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1649 done
1650 
1651 # There might be people who depend on the old broken behavior: `$host'
1652 # used to hold the argument of --host etc.
1653 # FIXME: To remove some day.
1654 build=$build_alias
1655 host=$host_alias
1656 target=$target_alias
1657 
1658 # FIXME: To remove some day.
1659 if test "x$host_alias" != x; then
1660   if test "x$build_alias" = x; then
1661     cross_compiling=maybe
1662   elif test "x$build_alias" != "x$host_alias"; then
1663     cross_compiling=yes
1664   fi
1665 fi
1666 
1667 ac_tool_prefix=
1668 test -n "$host_alias" && ac_tool_prefix=$host_alias-
1669 
1670 test "$silent" = yes && exec 6>/dev/null
1671 
1672 
1673 ac_pwd=`pwd` && test -n "$ac_pwd" &&
1674 ac_ls_di=`ls -di .` &&
1675 ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1676   as_fn_error $? "working directory cannot be determined"
1677 test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1678   as_fn_error $? "pwd does not report name of working directory"
1679 
1680 
1681 # Find the source files, if location was not specified.
1682 if test -z "$srcdir"; then
1683   ac_srcdir_defaulted=yes
1684   # Try the directory containing this script, then the parent directory.
1685   ac_confdir=`$as_dirname -- "$as_myself" ||
1686 $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1687          X"$as_myself" : 'X\(//\)[^/]' \| \
1688          X"$as_myself" : 'X\(//\)$' \| \
1689          X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
1690 $as_echo X"$as_myself" |
1691     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
1692             s//\1/
1693             q
1694           }
1695           /^X\(\/\/\)[^/].*/{
1696             s//\1/
1697             q
1698           }
1699           /^X\(\/\/\)$/{
1700             s//\1/
1701             q
1702           }
1703           /^X\(\/\).*/{
1704             s//\1/
1705             q
1706           }
1707           s/.*/./; q'`
1708   srcdir=$ac_confdir
1709   if test ! -r "$srcdir/$ac_unique_file"; then
1710     srcdir=..
1711   fi
1712 else
1713   ac_srcdir_defaulted=no
1714 fi
1715 if test ! -r "$srcdir/$ac_unique_file"; then
1716   test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1717   as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1718 fi
1719 ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1720 ac_abs_confdir=`(
1721         cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1722         pwd)`
1723 # When building in place, set srcdir=.
1724 if test "$ac_abs_confdir" = "$ac_pwd"; then
1725   srcdir=.
1726 fi
1727 # Remove unnecessary trailing slashes from srcdir.
1728 # Double slashes in file names in object file debugging info
1729 # mess up M-x gdb in Emacs.
1730 case $srcdir in
1731 */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
1732 esac
1733 for ac_var in $ac_precious_vars; do
1734   eval ac_env_${ac_var}_set=\${${ac_var}+set}
1735   eval ac_env_${ac_var}_value=\$${ac_var}
1736   eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
1737   eval ac_cv_env_${ac_var}_value=\$${ac_var}
1738 done
1739 
1740 #
1741 # Report the --help message.
1742 #
1743 if test "$ac_init_help" = "long"; then
1744   # Omit some internal or obsolete options to make the list less imposing.
1745   # This message is too long to be a string in the A/UX 3.1 sh.
1746   cat <<_ACEOF
1747 \`configure' configures OpenJDK jdk9 to adapt to many kinds of systems.
1748 
1749 Usage: $0 [OPTION]... [VAR=VALUE]...
1750 
1751 To assign environment variables (e.g., CC, CFLAGS...), specify them as
1752 VAR=VALUE.  See below for descriptions of some of the useful variables.
1753 
1754 Defaults for the options are specified in brackets.
1755 
1756 Configuration:
1757   -h, --help              display this help and exit
1758       --help=short        display options specific to this package
1759       --help=recursive    display the short help of all the included packages
1760   -V, --version           display version information and exit
1761   -q, --quiet, --silent   do not print \`checking ...' messages
1762       --cache-file=FILE   cache test results in FILE [disabled]
1763   -C, --config-cache      alias for \`--cache-file=config.cache'
1764   -n, --no-create         do not create output files
1765       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
1766 
1767 Installation directories:
1768   --prefix=PREFIX         install architecture-independent files in PREFIX
1769                           [$ac_default_prefix]
1770   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
1771                           [PREFIX]
1772 
1773 By default, \`make install' will install all the files in
1774 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
1775 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
1776 for instance \`--prefix=\$HOME'.
1777 
1778 For better control, use the options below.
1779 
1780 Fine tuning of the installation directories:
1781   --bindir=DIR            user executables [EPREFIX/bin]
1782   --sbindir=DIR           system admin executables [EPREFIX/sbin]
1783   --libexecdir=DIR        program executables [EPREFIX/libexec]
1784   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
1785   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
1786   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
1787   --libdir=DIR            object code libraries [EPREFIX/lib]
1788   --includedir=DIR        C header files [PREFIX/include]
1789   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
1790   --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
1791   --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
1792   --infodir=DIR           info documentation [DATAROOTDIR/info]
1793   --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
1794   --mandir=DIR            man documentation [DATAROOTDIR/man]
1795   --docdir=DIR            documentation root [DATAROOTDIR/doc/openjdk]
1796   --htmldir=DIR           html documentation [DOCDIR]
1797   --dvidir=DIR            dvi documentation [DOCDIR]
1798   --pdfdir=DIR            pdf documentation [DOCDIR]
1799   --psdir=DIR             ps documentation [DOCDIR]
1800 _ACEOF
1801 
1802   cat <<\_ACEOF
1803 
1804 X features:
1805   --x-includes=DIR    X include files are in DIR
1806   --x-libraries=DIR   X library files are in DIR
1807 
1808 System types:
1809   --build=BUILD     configure for building on BUILD [guessed]
1810   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
1811   --target=TARGET   configure for building compilers for TARGET [HOST]
1812 _ACEOF
1813 fi
1814 
1815 if test -n "$ac_init_help"; then
1816   case $ac_init_help in
1817      short | recursive ) echo "Configuration of OpenJDK jdk9:";;
1818    esac
1819   cat <<\_ACEOF
1820 
1821 Optional Features:
1822   --disable-option-checking  ignore unrecognized --enable/--with options
1823   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1824   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
1825   --enable-openjdk-only   suppress building custom source even if present
1826                           [disabled]
1827   --enable-debug          set the debug level to fastdebug (shorthand for
1828                           --with-debug-level=fastdebug) [disabled]
1829   --disable-headful       disable building headful support (graphical UI
1830                           support) [enabled]
1831   --enable-hotspot-test-in-build
1832                           run the Queens test after Hotspot build [disabled]
1833   --enable-unlimited-crypto
1834                           Enable unlimited crypto policy [disabled]
1835   --enable-rmiconnector-iiop
1836                           enable the JMX RMIConnector iiop transport
1837                           [disabled]
1838   --disable-debug-symbols disable generation of debug symbols [enabled]
1839   --disable-zip-debug-info
1840                           disable zipping of debug-info files [enabled]
1841   --enable-macosx-runtime-support
1842                           Deprecated. Option is kept for backwards
1843                           compatibility and is ignored
1844   --disable-freetype-bundling
1845                           disable bundling of the freetype library with the
1846                           build result [enabled on Windows or when using
1847                           --with-freetype, disabled otherwise]
1848   --enable-sjavac         use sjavac to do fast incremental compiles
1849                           [disabled]
1850   --disable-precompiled-headers
1851                           disable using precompiled headers when compiling C++
1852                           [enabled]
1853   --enable-ccache         enable using ccache to speed up recompilations
1854                           [disabled]
1855 
1856 Optional Packages:
1857   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1858   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
1859   --with-target-bits      build 32-bit or 64-bit binaries (for platforms that
1860                           support it), e.g. --with-target-bits=32 [guessed]
1861   --with-custom-make-dir  Deprecated. Option is kept for backwards
1862                           compatibility and is ignored
1863   --with-jdk-variant      JDK variant to build (normal) [normal]
1864   --with-jvm-interpreter  JVM interpreter to build (template, cpp) [template]
1865   --with-jvm-variants     JVM variants (separated by commas) to build (server,
1866                           client, minimal1, kernel, zero, zeroshark, core)
1867                           [server]
1868   --with-debug-level      set the debug level (release, fastdebug, slowdebug,
1869                           optimized (HotSpot build only)) [release]
1870   --with-devkit           use this devkit for compilers, tools and resources
1871   --with-sys-root         alias for --with-sysroot for backwards compatability
1872   --with-sysroot          use this directory as sysroot)
1873   --with-tools-dir        alias for --with-toolchain-path for backwards
1874                           compatibility
1875   --with-toolchain-path   prepend these directories when searching for
1876                           toolchain binaries (compilers etc)
1877   --with-extra-path       prepend these directories to the default path
1878   --with-conf-name        use this as the name of the configuration [generated
1879                           from important configuration options]
1880   --with-builddeps-conf   use this configuration file for the builddeps
1881   --with-builddeps-server download and use build dependencies from this server
1882                           url
1883   --with-builddeps-dir    store downloaded build dependencies here
1884                           [/localhome/builddeps]
1885   --with-builddeps-group  chgrp the downloaded build dependencies to this
1886                           group
1887   --with-cacerts-file     specify alternative cacerts file
1888   --with-milestone        Set milestone value for build [internal]
1889   --with-update-version   Set update version value for build [b00]
1890   --with-user-release-suffix
1891                           Add a custom string to the version string if build
1892                           number is not set.[username_builddateb00]
1893   --with-build-number     Set build number value for build [b00]
1894   --with-boot-jdk         path to Boot JDK (used to bootstrap build) [probed]
1895   --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
1896                           invocations of boot JDK, overriding the default
1897                           values, e.g --with-boot-jdk-jvmargs="-Xmx8G
1898                           -enableassertions"
1899   --with-add-source-root  for each and every source directory, look in this
1900                           additional source root for the same directory; if it
1901                           exists and have files in it, include it in the build
1902   --with-override-source-root
1903                           for each and every source directory, look in this
1904                           override source root for the same directory; if it
1905                           exists, use that directory instead and ignore the
1906                           directory in the original source root
1907   --with-adds-and-overrides
1908                           use the subdirs 'adds' and 'overrides' in the
1909                           specified directory as add-source-root and
1910                           override-source-root
1911   --with-override-langtools
1912                           use this langtools dir for the build
1913   --with-override-corba   use this corba dir for the build
1914   --with-override-jaxp    use this jaxp dir for the build
1915   --with-override-jaxws   use this jaxws dir for the build
1916   --with-override-hotspot use this hotspot dir for the build
1917   --with-override-nashorn use this nashorn dir for the build
1918   --with-override-jdk     use this jdk dir for the build
1919   --with-import-hotspot   import hotspot binaries from this jdk image or
1920                           hotspot build dist dir instead of building from
1921                           source
1922   --with-toolchain-type   the toolchain type (or family) to use, use '--help'
1923                           to show possible values [platform dependent]
1924   --with-jtreg            Regression Test Harness [probed]
1925   --with-extra-cflags     extra flags to be used when compiling jdk c-files
1926   --with-extra-cxxflags   extra flags to be used when compiling jdk c++-files
1927   --with-extra-ldflags    extra flags to be used when linking jdk
1928   --with-x                use the X Window System
1929   --with-cups             specify prefix directory for the cups package
1930                           (expecting the headers under PATH/include)
1931   --with-cups-include     specify directory for the cups include files
1932   --with-freetype         specify prefix directory for the freetype package
1933                           (expecting the libraries under PATH/lib and the
1934                           headers under PATH/include)
1935   --with-freetype-include specify directory for the freetype include files
1936   --with-freetype-lib     specify directory for the freetype library
1937   --with-alsa             specify prefix directory for the alsa package
1938                           (expecting the libraries under PATH/lib and the
1939                           headers under PATH/include)
1940   --with-alsa-include     specify directory for the alsa include files
1941   --with-alsa-lib         specify directory for the alsa library
1942   --with-libjpeg          use libjpeg from build system or OpenJDK source
1943                           (system, bundled) @<:bundled]
1944   --with-giflib           use giflib from build system or OpenJDK source
1945                           (system, bundled) [bundled]
1946   --with-lcms             use lcms2 from build system or OpenJDK source
1947                           (system, bundled) [bundled]
1948   --with-libpng           use libpng from build system or OpenJDK source
1949                           (system, bundled) [bundled]
1950   --with-zlib             use zlib from build system or OpenJDK source
1951                           (system, bundled) [bundled]
1952   --with-stdc++lib=<static>,<dynamic>,<default>
1953                           force linking of the C++ runtime on Linux to either
1954                           static or dynamic, default is static with dynamic as
1955                           fallback
1956   --with-msvcr-dll        copy this msvcr100.dll into the built JDK (Windows
1957                           only) [probed]
1958   --with-dxsdk            Deprecated. Option is kept for backwards
1959                           compatibility and is ignored
1960   --with-dxsdk-lib        Deprecated. Option is kept for backwards
1961                           compatibility and is ignored
1962   --with-dxsdk-include    Deprecated. Option is kept for backwards
1963                           compatibility and is ignored
1964   --with-num-cores        number of cores in the build system, e.g.
1965                           --with-num-cores=8 [probed]
1966   --with-memory-size      memory (in MB) available in the build system, e.g.
1967                           --with-memory-size=1024 [probed]
1968   --with-jobs             number of parallel jobs to let make run [calculated
1969                           based on cores and memory]
1970   --with-sjavac-server-java
1971                           use this java binary for running the sjavac
1972                           background server [Boot JDK java]
1973   --with-ccache-dir       where to store ccache files [~/.ccache]
1974 
1975 Some influential environment variables:
1976   BASENAME    Override default value for BASENAME
1977   BASH        Override default value for BASH
1978   CAT         Override default value for CAT
1979   CHMOD       Override default value for CHMOD
1980   CMP         Override default value for CMP
1981   COMM        Override default value for COMM
1982   CP          Override default value for CP
1983   CPIO        Override default value for CPIO
1984   CUT         Override default value for CUT
1985   DATE        Override default value for DATE
1986   DIFF        Override default value for DIFF
1987   DIRNAME     Override default value for DIRNAME
1988   ECHO        Override default value for ECHO
1989   EXPR        Override default value for EXPR
1990   FILE        Override default value for FILE
1991   FIND        Override default value for FIND
1992   HEAD        Override default value for HEAD
1993   LN          Override default value for LN
1994   LS          Override default value for LS
1995   MKDIR       Override default value for MKDIR
1996   MKTEMP      Override default value for MKTEMP
1997   MV          Override default value for MV
1998   NAWK        Override default value for NAWK
1999   PRINTF      Override default value for PRINTF
2000   RM          Override default value for RM
2001   SH          Override default value for SH
2002   SORT        Override default value for SORT
2003   TAIL        Override default value for TAIL
2004   TAR         Override default value for TAR
2005   TEE         Override default value for TEE
2006   TOUCH       Override default value for TOUCH
2007   TR          Override default value for TR
2008   UNAME       Override default value for UNAME
2009   UNIQ        Override default value for UNIQ
2010   WC          Override default value for WC
2011   WHICH       Override default value for WHICH
2012   XARGS       Override default value for XARGS
2013   AWK         Override default value for AWK
2014   GREP        Override default value for GREP
2015   EGREP       Override default value for EGREP
2016   FGREP       Override default value for FGREP
2017   SED         Override default value for SED
2018   CYGPATH     Override default value for CYGPATH
2019   READLINK    Override default value for READLINK
2020   DF          Override default value for DF
2021   SETFILE     Override default value for SETFILE
2022   UNZIP       Override default value for UNZIP
2023   ZIP         Override default value for ZIP
2024   LDD         Override default value for LDD
2025   OTOOL       Override default value for OTOOL
2026   READELF     Override default value for READELF
2027   HG          Override default value for HG
2028   STAT        Override default value for STAT
2029   TIME        Override default value for TIME
2030   DSYMUTIL    Override default value for DSYMUTIL
2031   XATTR       Override default value for XATTR
2032   CODESIGN    Override default value for CODESIGN
2033   PKG_CONFIG  path to pkg-config utility
2034   JAVA        Override default value for JAVA
2035   JAVAC       Override default value for JAVAC
2036   JAVAH       Override default value for JAVAH
2037   JAR         Override default value for JAR
2038   NATIVE2ASCII
2039               Override default value for NATIVE2ASCII
2040   JARSIGNER   Override default value for JARSIGNER
2041   CC          C compiler command
2042   CFLAGS      C compiler flags
2043   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
2044               nonstandard directory <lib dir>
2045   LIBS        libraries to pass to the linker, e.g. -l<library>
2046   CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
2047               you have headers in a nonstandard directory <include dir>
2048   CXX         C++ compiler command
2049   CXXFLAGS    C++ compiler flags
2050   CPP         C preprocessor
2051   CXXCPP      C++ preprocessor
2052   AS          Override default value for AS
2053   AR          Override default value for AR
2054   OBJC        Objective C compiler command
2055   OBJCFLAGS   Objective C compiler flags
2056   LIPO        Override default value for LIPO
2057   STRIP       Override default value for STRIP
2058   NM          Override default value for NM
2059   GNM         Override default value for GNM
2060   MCS         Override default value for MCS
2061   OBJCOPY     Override default value for OBJCOPY
2062   OBJDUMP     Override default value for OBJDUMP
2063   BUILD_CC    Override default value for BUILD_CC
2064   BUILD_CXX   Override default value for BUILD_CXX
2065   BUILD_LD    Override default value for BUILD_LD
2066   JTREGEXE    Override default value for JTREGEXE
2067   XMKMF       Path to xmkmf, Makefile generator for X Window System
2068   FREETYPE_CFLAGS
2069               C compiler flags for FREETYPE, overriding pkg-config
2070   FREETYPE_LIBS
2071               linker flags for FREETYPE, overriding pkg-config
2072   ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
2073   ALSA_LIBS   linker flags for ALSA, overriding pkg-config
2074   LCMS_CFLAGS C compiler flags for LCMS, overriding pkg-config
2075   LCMS_LIBS   linker flags for LCMS, overriding pkg-config
2076   PNG_CFLAGS  C compiler flags for PNG, overriding pkg-config
2077   PNG_LIBS    linker flags for PNG, overriding pkg-config
2078   LIBFFI_CFLAGS
2079               C compiler flags for LIBFFI, overriding pkg-config
2080   LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
2081   CCACHE      Override default value for CCACHE
2082 
2083 Use these variables to override the choices made by `configure' or to help
2084 it to find libraries and programs with nonstandard names/locations.
2085 
2086 Report bugs to <build-dev@openjdk.java.net>.
2087 OpenJDK home page: <http://openjdk.java.net>.
2088 _ACEOF
2089 ac_status=$?
2090 fi
2091 
2092 if test "$ac_init_help" = "recursive"; then
2093   # If there are subdirs, report their specific --help.
2094   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
2095     test -d "$ac_dir" ||
2096       { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
2097       continue
2098     ac_builddir=.
2099 
2100 case "$ac_dir" in
2101 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
2102 *)
2103   ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
2104   # A ".." for each directory in $ac_dir_suffix.
2105   ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
2106   case $ac_top_builddir_sub in
2107   "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
2108   *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
2109   esac ;;
2110 esac
2111 ac_abs_top_builddir=$ac_pwd
2112 ac_abs_builddir=$ac_pwd$ac_dir_suffix
2113 # for backward compatibility:
2114 ac_top_builddir=$ac_top_build_prefix
2115 
2116 case $srcdir in
2117   .)  # We are building in place.
2118     ac_srcdir=.
2119     ac_top_srcdir=$ac_top_builddir_sub
2120     ac_abs_top_srcdir=$ac_pwd ;;
2121   [\\/]* | ?:[\\/]* )  # Absolute name.
2122     ac_srcdir=$srcdir$ac_dir_suffix;
2123     ac_top_srcdir=$srcdir
2124     ac_abs_top_srcdir=$srcdir ;;
2125   *) # Relative name.
2126     ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
2127     ac_top_srcdir=$ac_top_build_prefix$srcdir
2128     ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
2129 esac
2130 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
2131 
2132     cd "$ac_dir" || { ac_status=$?; continue; }
2133     # Check for guested configure.
2134     if test -f "$ac_srcdir/configure.gnu"; then
2135       echo &&
2136       $SHELL "$ac_srcdir/configure.gnu" --help=recursive
2137     elif test -f "$ac_srcdir/configure"; then
2138       echo &&
2139       $SHELL "$ac_srcdir/configure" --help=recursive
2140     else
2141       $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
2142     fi || ac_status=$?
2143     cd "$ac_pwd" || { ac_status=$?; break; }
2144   done
2145 fi
2146 
2147 test -n "$ac_init_help" && exit $ac_status
2148 if $ac_init_version; then
2149   cat <<\_ACEOF
2150 OpenJDK configure jdk9
2151 generated by GNU Autoconf 2.69
2152 
2153 Copyright (C) 2012 Free Software Foundation, Inc.
2154 This configure script is free software; the Free Software Foundation
2155 gives unlimited permission to copy, distribute and modify it.
2156 _ACEOF
2157   exit
2158 fi
2159 
2160 ## ------------------------ ##
2161 ## Autoconf initialization. ##
2162 ## ------------------------ ##
2163 
2164 # ac_fn_c_try_compile LINENO
2165 # --------------------------
2166 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2167 ac_fn_c_try_compile ()
2168 {
2169   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2170   rm -f conftest.$ac_objext
2171   if { { ac_try="$ac_compile"
2172 case "(($ac_try" in
2173   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2174   *) ac_try_echo=$ac_try;;
2175 esac
2176 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2177 $as_echo "$ac_try_echo"; } >&5
2178   (eval "$ac_compile") 2>conftest.err
2179   ac_status=$?
2180   if test -s conftest.err; then
2181     grep -v '^ *+' conftest.err >conftest.er1
2182     cat conftest.er1 >&5
2183     mv -f conftest.er1 conftest.err
2184   fi
2185   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2186   test $ac_status = 0; } && {
2187          test -z "$ac_c_werror_flag" ||
2188          test ! -s conftest.err
2189        } && test -s conftest.$ac_objext; then :
2190   ac_retval=0
2191 else
2192   $as_echo "$as_me: failed program was:" >&5
2193 sed 's/^/| /' conftest.$ac_ext >&5
2194 
2195         ac_retval=1
2196 fi
2197   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2198   as_fn_set_status $ac_retval
2199 
2200 } # ac_fn_c_try_compile
2201 
2202 # ac_fn_cxx_try_compile LINENO
2203 # ----------------------------
2204 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2205 ac_fn_cxx_try_compile ()
2206 {
2207   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2208   rm -f conftest.$ac_objext
2209   if { { ac_try="$ac_compile"
2210 case "(($ac_try" in
2211   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2212   *) ac_try_echo=$ac_try;;
2213 esac
2214 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2215 $as_echo "$ac_try_echo"; } >&5
2216   (eval "$ac_compile") 2>conftest.err
2217   ac_status=$?
2218   if test -s conftest.err; then
2219     grep -v '^ *+' conftest.err >conftest.er1
2220     cat conftest.er1 >&5
2221     mv -f conftest.er1 conftest.err
2222   fi
2223   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2224   test $ac_status = 0; } && {
2225          test -z "$ac_cxx_werror_flag" ||
2226          test ! -s conftest.err
2227        } && test -s conftest.$ac_objext; then :
2228   ac_retval=0
2229 else
2230   $as_echo "$as_me: failed program was:" >&5
2231 sed 's/^/| /' conftest.$ac_ext >&5
2232 
2233         ac_retval=1
2234 fi
2235   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2236   as_fn_set_status $ac_retval
2237 
2238 } # ac_fn_cxx_try_compile
2239 
2240 # ac_fn_c_try_cpp LINENO
2241 # ----------------------
2242 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2243 ac_fn_c_try_cpp ()
2244 {
2245   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2246   if { { ac_try="$ac_cpp conftest.$ac_ext"
2247 case "(($ac_try" in
2248   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2249   *) ac_try_echo=$ac_try;;
2250 esac
2251 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2252 $as_echo "$ac_try_echo"; } >&5
2253   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2254   ac_status=$?
2255   if test -s conftest.err; then
2256     grep -v '^ *+' conftest.err >conftest.er1
2257     cat conftest.er1 >&5
2258     mv -f conftest.er1 conftest.err
2259   fi
2260   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2261   test $ac_status = 0; } > conftest.i && {
2262          test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
2263          test ! -s conftest.err
2264        }; then :
2265   ac_retval=0
2266 else
2267   $as_echo "$as_me: failed program was:" >&5
2268 sed 's/^/| /' conftest.$ac_ext >&5
2269 
2270     ac_retval=1
2271 fi
2272   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2273   as_fn_set_status $ac_retval
2274 
2275 } # ac_fn_c_try_cpp
2276 
2277 # ac_fn_cxx_try_cpp LINENO
2278 # ------------------------
2279 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2280 ac_fn_cxx_try_cpp ()
2281 {
2282   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2283   if { { ac_try="$ac_cpp conftest.$ac_ext"
2284 case "(($ac_try" in
2285   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2286   *) ac_try_echo=$ac_try;;
2287 esac
2288 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2289 $as_echo "$ac_try_echo"; } >&5
2290   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2291   ac_status=$?
2292   if test -s conftest.err; then
2293     grep -v '^ *+' conftest.err >conftest.er1
2294     cat conftest.er1 >&5
2295     mv -f conftest.er1 conftest.err
2296   fi
2297   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2298   test $ac_status = 0; } > conftest.i && {
2299          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2300          test ! -s conftest.err
2301        }; then :
2302   ac_retval=0
2303 else
2304   $as_echo "$as_me: failed program was:" >&5
2305 sed 's/^/| /' conftest.$ac_ext >&5
2306 
2307     ac_retval=1
2308 fi
2309   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2310   as_fn_set_status $ac_retval
2311 
2312 } # ac_fn_cxx_try_cpp
2313 
2314 # ac_fn_objc_try_compile LINENO
2315 # -----------------------------
2316 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2317 ac_fn_objc_try_compile ()
2318 {
2319   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2320   rm -f conftest.$ac_objext
2321   if { { ac_try="$ac_compile"
2322 case "(($ac_try" in
2323   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2324   *) ac_try_echo=$ac_try;;
2325 esac
2326 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2327 $as_echo "$ac_try_echo"; } >&5
2328   (eval "$ac_compile") 2>conftest.err
2329   ac_status=$?
2330   if test -s conftest.err; then
2331     grep -v '^ *+' conftest.err >conftest.er1
2332     cat conftest.er1 >&5
2333     mv -f conftest.er1 conftest.err
2334   fi
2335   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2336   test $ac_status = 0; } && {
2337          test -z "$ac_objc_werror_flag" ||
2338          test ! -s conftest.err
2339        } && test -s conftest.$ac_objext; then :
2340   ac_retval=0
2341 else
2342   $as_echo "$as_me: failed program was:" >&5
2343 sed 's/^/| /' conftest.$ac_ext >&5
2344 
2345         ac_retval=1
2346 fi
2347   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2348   as_fn_set_status $ac_retval
2349 
2350 } # ac_fn_objc_try_compile
2351 
2352 # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2353 # ---------------------------------------------------------
2354 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2355 # the include files in INCLUDES and setting the cache variable VAR
2356 # accordingly.
2357 ac_fn_cxx_check_header_mongrel ()
2358 {
2359   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2360   if eval \${$3+:} false; then :
2361   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2362 $as_echo_n "checking for $2... " >&6; }
2363 if eval \${$3+:} false; then :
2364   $as_echo_n "(cached) " >&6
2365 fi
2366 eval ac_res=\$$3
2367                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2368 $as_echo "$ac_res" >&6; }
2369 else
2370   # Is the header compilable?
2371 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2372 $as_echo_n "checking $2 usability... " >&6; }
2373 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2374 /* end confdefs.h.  */
2375 $4
2376 #include <$2>
2377 _ACEOF
2378 if ac_fn_cxx_try_compile "$LINENO"; then :
2379   ac_header_compiler=yes
2380 else
2381   ac_header_compiler=no
2382 fi
2383 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2384 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2385 $as_echo "$ac_header_compiler" >&6; }
2386 
2387 # Is the header present?
2388 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2389 $as_echo_n "checking $2 presence... " >&6; }
2390 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2391 /* end confdefs.h.  */
2392 #include <$2>
2393 _ACEOF
2394 if ac_fn_cxx_try_cpp "$LINENO"; then :
2395   ac_header_preproc=yes
2396 else
2397   ac_header_preproc=no
2398 fi
2399 rm -f conftest.err conftest.i conftest.$ac_ext
2400 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2401 $as_echo "$ac_header_preproc" >&6; }
2402 
2403 # So?  What about this header?
2404 case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2405   yes:no: )
2406     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2407 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2408     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2409 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2410     ;;
2411   no:yes:* )
2412     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2413 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2414     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
2415 $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
2416     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2417 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2418     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
2419 $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
2420     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2421 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2422 ( $as_echo "## ----------------------------------------- ##
2423 ## Report this to build-dev@openjdk.java.net ##
2424 ## ----------------------------------------- ##"
2425      ) | sed "s/^/$as_me: WARNING:     /" >&2
2426     ;;
2427 esac
2428   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2429 $as_echo_n "checking for $2... " >&6; }
2430 if eval \${$3+:} false; then :
2431   $as_echo_n "(cached) " >&6
2432 else
2433   eval "$3=\$ac_header_compiler"
2434 fi
2435 eval ac_res=\$$3
2436                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2437 $as_echo "$ac_res" >&6; }
2438 fi
2439   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2440 
2441 } # ac_fn_cxx_check_header_mongrel
2442 
2443 # ac_fn_cxx_try_run LINENO
2444 # ------------------------
2445 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2446 # that executables *can* be run.
2447 ac_fn_cxx_try_run ()
2448 {
2449   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2450   if { { ac_try="$ac_link"
2451 case "(($ac_try" in
2452   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2453   *) ac_try_echo=$ac_try;;
2454 esac
2455 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2456 $as_echo "$ac_try_echo"; } >&5
2457   (eval "$ac_link") 2>&5
2458   ac_status=$?
2459   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2460   test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2461   { { case "(($ac_try" in
2462   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2463   *) ac_try_echo=$ac_try;;
2464 esac
2465 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2466 $as_echo "$ac_try_echo"; } >&5
2467   (eval "$ac_try") 2>&5
2468   ac_status=$?
2469   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2470   test $ac_status = 0; }; }; then :
2471   ac_retval=0
2472 else
2473   $as_echo "$as_me: program exited with status $ac_status" >&5
2474        $as_echo "$as_me: failed program was:" >&5
2475 sed 's/^/| /' conftest.$ac_ext >&5
2476 
2477        ac_retval=$ac_status
2478 fi
2479   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2480   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2481   as_fn_set_status $ac_retval
2482 
2483 } # ac_fn_cxx_try_run
2484 
2485 # ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
2486 # ---------------------------------------------------------
2487 # Tests whether HEADER exists and can be compiled using the include files in
2488 # INCLUDES, setting the cache variable VAR accordingly.
2489 ac_fn_cxx_check_header_compile ()
2490 {
2491   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2492   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2493 $as_echo_n "checking for $2... " >&6; }
2494 if eval \${$3+:} false; then :
2495   $as_echo_n "(cached) " >&6
2496 else
2497   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2498 /* end confdefs.h.  */
2499 $4
2500 #include <$2>
2501 _ACEOF
2502 if ac_fn_cxx_try_compile "$LINENO"; then :
2503   eval "$3=yes"
2504 else
2505   eval "$3=no"
2506 fi
2507 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2508 fi
2509 eval ac_res=\$$3
2510                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2511 $as_echo "$ac_res" >&6; }
2512   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2513 
2514 } # ac_fn_cxx_check_header_compile
2515 
2516 # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
2517 # ----------------------------------------------
2518 # Tries to find the compile-time value of EXPR in a program that includes
2519 # INCLUDES, setting VAR accordingly. Returns whether the value could be
2520 # computed
2521 ac_fn_cxx_compute_int ()
2522 {
2523   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2524   if test "$cross_compiling" = yes; then
2525     # Depending upon the size, compute the lo and hi bounds.
2526 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2527 /* end confdefs.h.  */
2528 $4
2529 int
2530 main ()
2531 {
2532 static int test_array [1 - 2 * !(($2) >= 0)];
2533 test_array [0] = 0;
2534 return test_array [0];
2535 
2536   ;
2537   return 0;
2538 }
2539 _ACEOF
2540 if ac_fn_cxx_try_compile "$LINENO"; then :
2541   ac_lo=0 ac_mid=0
2542   while :; do
2543     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2544 /* end confdefs.h.  */
2545 $4
2546 int
2547 main ()
2548 {
2549 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2550 test_array [0] = 0;
2551 return test_array [0];
2552 
2553   ;
2554   return 0;
2555 }
2556 _ACEOF
2557 if ac_fn_cxx_try_compile "$LINENO"; then :
2558   ac_hi=$ac_mid; break
2559 else
2560   as_fn_arith $ac_mid + 1 && ac_lo=$as_val
2561                         if test $ac_lo -le $ac_mid; then
2562                           ac_lo= ac_hi=
2563                           break
2564                         fi
2565                         as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
2566 fi
2567 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2568   done
2569 else
2570   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2571 /* end confdefs.h.  */
2572 $4
2573 int
2574 main ()
2575 {
2576 static int test_array [1 - 2 * !(($2) < 0)];
2577 test_array [0] = 0;
2578 return test_array [0];
2579 
2580   ;
2581   return 0;
2582 }
2583 _ACEOF
2584 if ac_fn_cxx_try_compile "$LINENO"; then :
2585   ac_hi=-1 ac_mid=-1
2586   while :; do
2587     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2588 /* end confdefs.h.  */
2589 $4
2590 int
2591 main ()
2592 {
2593 static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2594 test_array [0] = 0;
2595 return test_array [0];
2596 
2597   ;
2598   return 0;
2599 }
2600 _ACEOF
2601 if ac_fn_cxx_try_compile "$LINENO"; then :
2602   ac_lo=$ac_mid; break
2603 else
2604   as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2605                         if test $ac_mid -le $ac_hi; then
2606                           ac_lo= ac_hi=
2607                           break
2608                         fi
2609                         as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2610 fi
2611 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2612   done
2613 else
2614   ac_lo= ac_hi=
2615 fi
2616 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2617 fi
2618 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2619 # Binary search between lo and hi bounds.
2620 while test "x$ac_lo" != "x$ac_hi"; do
2621   as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2622   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2623 /* end confdefs.h.  */
2624 $4
2625 int
2626 main ()
2627 {
2628 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2629 test_array [0] = 0;
2630 return test_array [0];
2631 
2632   ;
2633   return 0;
2634 }
2635 _ACEOF
2636 if ac_fn_cxx_try_compile "$LINENO"; then :
2637   ac_hi=$ac_mid
2638 else
2639   as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2640 fi
2641 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2642 done
2643 case $ac_lo in #((
2644 ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2645 '') ac_retval=1 ;;
2646 esac
2647   else
2648     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2649 /* end confdefs.h.  */
2650 $4
2651 static long int longval () { return $2; }
2652 static unsigned long int ulongval () { return $2; }
2653 #include <stdio.h>
2654 #include <stdlib.h>
2655 int
2656 main ()
2657 {
2658 
2659   FILE *f = fopen ("conftest.val", "w");
2660   if (! f)
2661     return 1;
2662   if (($2) < 0)
2663     {
2664       long int i = longval ();
2665       if (i != ($2))
2666         return 1;
2667       fprintf (f, "%ld", i);
2668     }
2669   else
2670     {
2671       unsigned long int i = ulongval ();
2672       if (i != ($2))
2673         return 1;
2674       fprintf (f, "%lu", i);
2675     }
2676   /* Do not output a trailing newline, as this causes \r\n confusion
2677      on some platforms.  */
2678   return ferror (f) || fclose (f) != 0;
2679 
2680   ;
2681   return 0;
2682 }
2683 _ACEOF
2684 if ac_fn_cxx_try_run "$LINENO"; then :
2685   echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2686 else
2687   ac_retval=1
2688 fi
2689 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2690   conftest.$ac_objext conftest.beam conftest.$ac_ext
2691 rm -f conftest.val
2692 
2693   fi
2694   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2695   as_fn_set_status $ac_retval
2696 
2697 } # ac_fn_cxx_compute_int
2698 
2699 # ac_fn_cxx_try_link LINENO
2700 # -------------------------
2701 # Try to link conftest.$ac_ext, and return whether this succeeded.
2702 ac_fn_cxx_try_link ()
2703 {
2704   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2705   rm -f conftest.$ac_objext conftest$ac_exeext
2706   if { { ac_try="$ac_link"
2707 case "(($ac_try" in
2708   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2709   *) ac_try_echo=$ac_try;;
2710 esac
2711 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2712 $as_echo "$ac_try_echo"; } >&5
2713   (eval "$ac_link") 2>conftest.err
2714   ac_status=$?
2715   if test -s conftest.err; then
2716     grep -v '^ *+' conftest.err >conftest.er1
2717     cat conftest.er1 >&5
2718     mv -f conftest.er1 conftest.err
2719   fi
2720   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2721   test $ac_status = 0; } && {
2722          test -z "$ac_cxx_werror_flag" ||
2723          test ! -s conftest.err
2724        } && test -s conftest$ac_exeext && {
2725          test "$cross_compiling" = yes ||
2726          test -x conftest$ac_exeext
2727        }; then :
2728   ac_retval=0
2729 else
2730   $as_echo "$as_me: failed program was:" >&5
2731 sed 's/^/| /' conftest.$ac_ext >&5
2732 
2733         ac_retval=1
2734 fi
2735   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2736   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2737   # interfere with the next link command; also delete a directory that is
2738   # left behind by Apple's compiler.  We do this before executing the actions.
2739   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2740   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2741   as_fn_set_status $ac_retval
2742 
2743 } # ac_fn_cxx_try_link
2744 
2745 # ac_fn_cxx_check_func LINENO FUNC VAR
2746 # ------------------------------------
2747 # Tests whether FUNC exists, setting the cache variable VAR accordingly
2748 ac_fn_cxx_check_func ()
2749 {
2750   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2751   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2752 $as_echo_n "checking for $2... " >&6; }
2753 if eval \${$3+:} false; then :
2754   $as_echo_n "(cached) " >&6
2755 else
2756   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2757 /* end confdefs.h.  */
2758 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
2759    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
2760 #define $2 innocuous_$2
2761 
2762 /* System header to define __stub macros and hopefully few prototypes,
2763     which can conflict with char $2 (); below.
2764     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2765     <limits.h> exists even on freestanding compilers.  */
2766 
2767 #ifdef __STDC__
2768 # include <limits.h>
2769 #else
2770 # include <assert.h>
2771 #endif
2772 
2773 #undef $2
2774 
2775 /* Override any GCC internal prototype to avoid an error.
2776    Use char because int might match the return type of a GCC
2777    builtin and then its argument prototype would still apply.  */
2778 #ifdef __cplusplus
2779 extern "C"
2780 #endif
2781 char $2 ();
2782 /* The GNU C library defines this for functions which it implements
2783     to always fail with ENOSYS.  Some functions are actually named
2784     something starting with __ and the normal name is an alias.  */
2785 #if defined __stub_$2 || defined __stub___$2
2786 choke me
2787 #endif
2788 
2789 int
2790 main ()
2791 {
2792 return $2 ();
2793   ;
2794   return 0;
2795 }
2796 _ACEOF
2797 if ac_fn_cxx_try_link "$LINENO"; then :
2798   eval "$3=yes"
2799 else
2800   eval "$3=no"
2801 fi
2802 rm -f core conftest.err conftest.$ac_objext \
2803     conftest$ac_exeext conftest.$ac_ext
2804 fi
2805 eval ac_res=\$$3
2806                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2807 $as_echo "$ac_res" >&6; }
2808   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2809 
2810 } # ac_fn_cxx_check_func
2811 
2812 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
2813 # -------------------------------------------------------
2814 # Tests whether HEADER exists and can be compiled using the include files in
2815 # INCLUDES, setting the cache variable VAR accordingly.
2816 ac_fn_c_check_header_compile ()
2817 {
2818   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2819   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2820 $as_echo_n "checking for $2... " >&6; }
2821 if eval \${$3+:} false; then :
2822   $as_echo_n "(cached) " >&6
2823 else
2824   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2825 /* end confdefs.h.  */
2826 $4
2827 #include <$2>
2828 _ACEOF
2829 if ac_fn_c_try_compile "$LINENO"; then :
2830   eval "$3=yes"
2831 else
2832   eval "$3=no"
2833 fi
2834 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2835 fi
2836 eval ac_res=\$$3
2837                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2838 $as_echo "$ac_res" >&6; }
2839   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2840 
2841 } # ac_fn_c_check_header_compile
2842 cat >config.log <<_ACEOF
2843 This file contains any messages produced by compilers while
2844 running configure, to aid debugging if configure makes a mistake.
2845 
2846 It was created by OpenJDK $as_me jdk9, which was
2847 generated by GNU Autoconf 2.69.  Invocation command line was
2848 
2849   $ $0 $@
2850 
2851 _ACEOF
2852 exec 5>>config.log
2853 {
2854 cat <<_ASUNAME
2855 ## --------- ##
2856 ## Platform. ##
2857 ## --------- ##
2858 
2859 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
2860 uname -m = `(uname -m) 2>/dev/null || echo unknown`
2861 uname -r = `(uname -r) 2>/dev/null || echo unknown`
2862 uname -s = `(uname -s) 2>/dev/null || echo unknown`
2863 uname -v = `(uname -v) 2>/dev/null || echo unknown`
2864 
2865 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
2866 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
2867 
2868 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
2869 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
2870 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
2871 /usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
2872 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
2873 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
2874 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
2875 
2876 _ASUNAME
2877 
2878 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2879 for as_dir in $PATH
2880 do
2881   IFS=$as_save_IFS
2882   test -z "$as_dir" && as_dir=.
2883     $as_echo "PATH: $as_dir"
2884   done
2885 IFS=$as_save_IFS
2886 
2887 } >&5
2888 
2889 cat >&5 <<_ACEOF
2890 
2891 
2892 ## ----------- ##
2893 ## Core tests. ##
2894 ## ----------- ##
2895 
2896 _ACEOF
2897 
2898 
2899 # Keep a trace of the command line.
2900 # Strip out --no-create and --no-recursion so they do not pile up.
2901 # Strip out --silent because we don't want to record it for future runs.
2902 # Also quote any args containing shell meta-characters.
2903 # Make two passes to allow for proper duplicate-argument suppression.
2904 ac_configure_args=
2905 ac_configure_args0=
2906 ac_configure_args1=
2907 ac_must_keep_next=false
2908 for ac_pass in 1 2
2909 do
2910   for ac_arg
2911   do
2912     case $ac_arg in
2913     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
2914     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
2915     | -silent | --silent | --silen | --sile | --sil)
2916       continue ;;
2917     *\'*)
2918       ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
2919     esac
2920     case $ac_pass in
2921     1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2922     2)
2923       as_fn_append ac_configure_args1 " '$ac_arg'"
2924       if test $ac_must_keep_next = true; then
2925         ac_must_keep_next=false # Got value, back to normal.
2926       else
2927         case $ac_arg in
2928           *=* | --config-cache | -C | -disable-* | --disable-* \
2929           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
2930           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
2931           | -with-* | --with-* | -without-* | --without-* | --x)
2932             case "$ac_configure_args0 " in
2933               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
2934             esac
2935             ;;
2936           -* ) ac_must_keep_next=true ;;
2937         esac
2938       fi
2939       as_fn_append ac_configure_args " '$ac_arg'"
2940       ;;
2941     esac
2942   done
2943 done
2944 { ac_configure_args0=; unset ac_configure_args0;}
2945 { ac_configure_args1=; unset ac_configure_args1;}
2946 
2947 # When interrupted or exit'd, cleanup temporary files, and complete
2948 # config.log.  We remove comments because anyway the quotes in there
2949 # would cause problems or look ugly.
2950 # WARNING: Use '\'' to represent an apostrophe within the trap.
2951 # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
2952 trap 'exit_status=$?
2953   # Save into config.log some information that might help in debugging.
2954   {
2955     echo
2956 
2957     $as_echo "## ---------------- ##
2958 ## Cache variables. ##
2959 ## ---------------- ##"
2960     echo
2961     # The following way of writing the cache mishandles newlines in values,
2962 (
2963   for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
2964     eval ac_val=\$$ac_var
2965     case $ac_val in #(
2966     *${as_nl}*)
2967       case $ac_var in #(
2968       *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
2969 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
2970       esac
2971       case $ac_var in #(
2972       _ | IFS | as_nl) ;; #(
2973       BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
2974       *) { eval $ac_var=; unset $ac_var;} ;;
2975       esac ;;
2976     esac
2977   done
2978   (set) 2>&1 |
2979     case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
2980     *${as_nl}ac_space=\ *)
2981       sed -n \
2982         "s/'\''/'\''\\\\'\'''\''/g;
2983           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
2984       ;; #(
2985     *)
2986       sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
2987       ;;
2988     esac |
2989     sort
2990 )
2991     echo
2992 
2993     $as_echo "## ----------------- ##
2994 ## Output variables. ##
2995 ## ----------------- ##"
2996     echo
2997     for ac_var in $ac_subst_vars
2998     do
2999       eval ac_val=\$$ac_var
3000       case $ac_val in
3001       *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3002       esac
3003       $as_echo "$ac_var='\''$ac_val'\''"
3004     done | sort
3005     echo
3006 
3007     if test -n "$ac_subst_files"; then
3008       $as_echo "## ------------------- ##
3009 ## File substitutions. ##
3010 ## ------------------- ##"
3011       echo
3012       for ac_var in $ac_subst_files
3013       do
3014         eval ac_val=\$$ac_var
3015         case $ac_val in
3016         *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3017         esac
3018         $as_echo "$ac_var='\''$ac_val'\''"
3019       done | sort
3020       echo
3021     fi
3022 
3023     if test -s confdefs.h; then
3024       $as_echo "## ----------- ##
3025 ## confdefs.h. ##
3026 ## ----------- ##"
3027       echo
3028       cat confdefs.h
3029       echo
3030     fi
3031     test "$ac_signal" != 0 &&
3032       $as_echo "$as_me: caught signal $ac_signal"
3033     $as_echo "$as_me: exit $exit_status"
3034   } >&5
3035   rm -f core *.core core.conftest.* &&
3036     rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
3037     exit $exit_status
3038 ' 0
3039 for ac_signal in 1 2 13 15; do
3040   trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
3041 done
3042 ac_signal=0
3043 
3044 # confdefs.h avoids OS command line length limits that DEFS can exceed.
3045 rm -f -r conftest* confdefs.h
3046 
3047 $as_echo "/* confdefs.h */" > confdefs.h
3048 
3049 # Predefined preprocessor variables.
3050 
3051 cat >>confdefs.h <<_ACEOF
3052 #define PACKAGE_NAME "$PACKAGE_NAME"
3053 _ACEOF
3054 
3055 cat >>confdefs.h <<_ACEOF
3056 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
3057 _ACEOF
3058 
3059 cat >>confdefs.h <<_ACEOF
3060 #define PACKAGE_VERSION "$PACKAGE_VERSION"
3061 _ACEOF
3062 
3063 cat >>confdefs.h <<_ACEOF
3064 #define PACKAGE_STRING "$PACKAGE_STRING"
3065 _ACEOF
3066 
3067 cat >>confdefs.h <<_ACEOF
3068 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
3069 _ACEOF
3070 
3071 cat >>confdefs.h <<_ACEOF
3072 #define PACKAGE_URL "$PACKAGE_URL"
3073 _ACEOF
3074 
3075 
3076 # Let the site file select an alternate cache file if it wants to.
3077 # Prefer an explicitly selected file to automatically selected ones.
3078 ac_site_file1=NONE
3079 ac_site_file2=NONE
3080 if test -n "$CONFIG_SITE"; then
3081   # We do not want a PATH search for config.site.
3082   case $CONFIG_SITE in #((
3083     -*)  ac_site_file1=./$CONFIG_SITE;;
3084     */*) ac_site_file1=$CONFIG_SITE;;
3085     *)   ac_site_file1=./$CONFIG_SITE;;
3086   esac
3087 elif test "x$prefix" != xNONE; then
3088   ac_site_file1=$prefix/share/config.site
3089   ac_site_file2=$prefix/etc/config.site
3090 else
3091   ac_site_file1=$ac_default_prefix/share/config.site
3092   ac_site_file2=$ac_default_prefix/etc/config.site
3093 fi
3094 for ac_site_file in "$ac_site_file1" "$ac_site_file2"
3095 do
3096   test "x$ac_site_file" = xNONE && continue
3097   if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
3098     { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
3099 $as_echo "$as_me: loading site script $ac_site_file" >&6;}
3100     sed 's/^/| /' "$ac_site_file" >&5
3101     . "$ac_site_file" \
3102       || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3103 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3104 as_fn_error $? "failed to load site script $ac_site_file
3105 See \`config.log' for more details" "$LINENO" 5; }
3106   fi
3107 done
3108 
3109 if test -r "$cache_file"; then
3110   # Some versions of bash will fail to source /dev/null (special files
3111   # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
3112   if test /dev/null != "$cache_file" && test -f "$cache_file"; then
3113     { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
3114 $as_echo "$as_me: loading cache $cache_file" >&6;}
3115     case $cache_file in
3116       [\\/]* | ?:[\\/]* ) . "$cache_file";;
3117       *)                      . "./$cache_file";;
3118     esac
3119   fi
3120 else
3121   { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
3122 $as_echo "$as_me: creating cache $cache_file" >&6;}
3123   >$cache_file
3124 fi
3125 
3126 # Check that the precious variables saved in the cache have kept the same
3127 # value.
3128 ac_cache_corrupted=false
3129 for ac_var in $ac_precious_vars; do
3130   eval ac_old_set=\$ac_cv_env_${ac_var}_set
3131   eval ac_new_set=\$ac_env_${ac_var}_set
3132   eval ac_old_val=\$ac_cv_env_${ac_var}_value
3133   eval ac_new_val=\$ac_env_${ac_var}_value
3134   case $ac_old_set,$ac_new_set in
3135     set,)
3136       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
3137 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
3138       ac_cache_corrupted=: ;;
3139     ,set)
3140       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
3141 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
3142       ac_cache_corrupted=: ;;
3143     ,);;
3144     *)
3145       if test "x$ac_old_val" != "x$ac_new_val"; then
3146         # differences in whitespace do not lead to failure.
3147         ac_old_val_w=`echo x $ac_old_val`
3148         ac_new_val_w=`echo x $ac_new_val`
3149         if test "$ac_old_val_w" != "$ac_new_val_w"; then
3150           { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
3151 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
3152           ac_cache_corrupted=:
3153         else
3154           { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
3155 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
3156           eval $ac_var=\$ac_old_val
3157         fi
3158         { $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
3159 $as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
3160         { $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
3161 $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
3162       fi;;
3163   esac
3164   # Pass precious variables to config.status.
3165   if test "$ac_new_set" = set; then
3166     case $ac_new_val in
3167     *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
3168     *) ac_arg=$ac_var=$ac_new_val ;;
3169     esac
3170     case " $ac_configure_args " in
3171       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
3172       *) as_fn_append ac_configure_args " '$ac_arg'" ;;
3173     esac
3174   fi
3175 done
3176 if $ac_cache_corrupted; then
3177   { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3178 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3179   { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
3180 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
3181   as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
3182 fi
3183 ## -------------------- ##
3184 ## Main body of script. ##
3185 ## -------------------- ##
3186 
3187 ac_ext=c
3188 ac_cpp='$CPP $CPPFLAGS'
3189 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3190 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3191 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3192 
3193 
3194 
3195 ac_aux_dir=
3196 for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
3197   if test -f "$ac_dir/install-sh"; then
3198     ac_aux_dir=$ac_dir
3199     ac_install_sh="$ac_aux_dir/install-sh -c"
3200     break
3201   elif test -f "$ac_dir/install.sh"; then
3202     ac_aux_dir=$ac_dir
3203     ac_install_sh="$ac_aux_dir/install.sh -c"
3204     break
3205   elif test -f "$ac_dir/shtool"; then
3206     ac_aux_dir=$ac_dir
3207     ac_install_sh="$ac_aux_dir/shtool install -c"
3208     break
3209   fi
3210 done
3211 if test -z "$ac_aux_dir"; then
3212   as_fn_error $? "cannot find install-sh, install.sh, or shtool in $TOPDIR/common/autoconf/build-aux \"$srcdir\"/$TOPDIR/common/autoconf/build-aux" "$LINENO" 5
3213 fi
3214 
3215 # These three variables are undocumented and unsupported,
3216 # and are intended to be withdrawn in a future Autoconf release.
3217 # They can cause serious problems if a builder's source tree is in a directory
3218 # whose full name contains unusual characters.
3219 ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
3220 ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
3221 ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
3222 
3223 
3224 # pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
3225 
3226 #
3227 # Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3228 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3229 #
3230 # This code is free software; you can redistribute it and/or modify it
3231 # under the terms of the GNU General Public License version 2 only, as
3232 # published by the Free Software Foundation.  Oracle designates this
3233 # particular file as subject to the "Classpath" exception as provided
3234 # by Oracle in the LICENSE file that accompanied this code.
3235 #
3236 # This code is distributed in the hope that it will be useful, but WITHOUT
3237 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3238 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3239 # version 2 for more details (a copy is included in the LICENSE file that
3240 # accompanied this code).
3241 #
3242 # You should have received a copy of the GNU General Public License version
3243 # 2 along with this work; if not, write to the Free Software Foundation,
3244 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3245 #
3246 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3247 # or visit www.oracle.com if you need additional information or have any
3248 # questions.
3249 #
3250 
3251 #
3252 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
3253 #
3254 # This program is free software; you can redistribute it and/or modify
3255 # it under the terms of the GNU General Public License as published by
3256 # the Free Software Foundation; either version 2 of the License, or
3257 # (at your option) any later version.
3258 #
3259 # This program is distributed in the hope that it will be useful, but
3260 # WITHOUT ANY WARRANTY; without even the implied warranty of
3261 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3262 # General Public License for more details.
3263 #
3264 # You should have received a copy of the GNU General Public License
3265 # along with this program; if not, write to the Free Software
3266 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3267 #
3268 # As a special exception to the GNU General Public License, if you
3269 # distribute this file as part of a program that contains a
3270 # configuration script generated by Autoconf, you may include it under
3271 # the same distribution terms that you use for the rest of that program.
3272 
3273 # PKG_PROG_PKG_CONFIG([MIN-VERSION])
3274 # ----------------------------------
3275 # PKG_PROG_PKG_CONFIG
3276 
3277 # PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
3278 #
3279 # Check to see whether a particular set of modules exists.  Similar
3280 # to PKG_CHECK_MODULES(), but does not set variables or print errors.
3281 #
3282 #
3283 # Similar to PKG_CHECK_MODULES, make sure that the first instance of
3284 # this or PKG_CHECK_MODULES is called, or make sure to call
3285 # PKG_CHECK_EXISTS manually
3286 # --------------------------------------------------------------
3287 
3288 
3289 
3290 # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
3291 # ---------------------------------------------
3292 # _PKG_CONFIG
3293 
3294 # _PKG_SHORT_ERRORS_SUPPORTED
3295 # -----------------------------
3296 # _PKG_SHORT_ERRORS_SUPPORTED
3297 
3298 
3299 # PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
3300 # [ACTION-IF-NOT-FOUND])
3301 #
3302 #
3303 # Note that if there is a possibility the first call to
3304 # PKG_CHECK_MODULES might not happen, you should be sure to include an
3305 # explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
3306 #
3307 #
3308 # --------------------------------------------------------------
3309 # PKG_CHECK_MODULES
3310 
3311 
3312 # Include these first...
3313 #
3314 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3315 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3316 #
3317 # This code is free software; you can redistribute it and/or modify it
3318 # under the terms of the GNU General Public License version 2 only, as
3319 # published by the Free Software Foundation.  Oracle designates this
3320 # particular file as subject to the "Classpath" exception as provided
3321 # by Oracle in the LICENSE file that accompanied this code.
3322 #
3323 # This code is distributed in the hope that it will be useful, but WITHOUT
3324 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3325 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3326 # version 2 for more details (a copy is included in the LICENSE file that
3327 # accompanied this code).
3328 #
3329 # You should have received a copy of the GNU General Public License version
3330 # 2 along with this work; if not, write to the Free Software Foundation,
3331 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3332 #
3333 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3334 # or visit www.oracle.com if you need additional information or have any
3335 # questions.
3336 #
3337 
3338 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3339 # If so, then append $1 to $2 \
3340 # Also set JVM_ARG_OK to true/false depending on outcome.
3341 
3342 
3343 # Appends a string to a path variable, only adding the : when needed.
3344 
3345 
3346 # Prepends a string to a path variable, only adding the : when needed.
3347 
3348 
3349 # This will make sure the given variable points to a full and proper
3350 # path. This means:
3351 # 1) There will be no spaces in the path. On posix platforms,
3352 #    spaces in the path will result in an error. On Windows,
3353 #    the path will be rewritten using short-style to be space-free.
3354 # 2) The path will be absolute, and it will be in unix-style (on
3355 #     cygwin).
3356 # $1: The name of the variable to fix
3357 
3358 
3359 # This will make sure the given variable points to a executable
3360 # with a full and proper path. This means:
3361 # 1) There will be no spaces in the path. On posix platforms,
3362 #    spaces in the path will result in an error. On Windows,
3363 #    the path will be rewritten using short-style to be space-free.
3364 # 2) The path will be absolute, and it will be in unix-style (on
3365 #     cygwin).
3366 # Any arguments given to the executable is preserved.
3367 # If the input variable does not have a directory specification, then
3368 # it need to be in the PATH.
3369 # $1: The name of the variable to fix
3370 
3371 
3372 
3373 
3374 # Register a --with argument but mark it as deprecated
3375 # $1: The name of the with argument to deprecate, not including --with-
3376 
3377 
3378 # Register a --enable argument but mark it as deprecated
3379 # $1: The name of the with argument to deprecate, not including --enable-
3380 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3381 
3382 
3383 
3384 
3385 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3386 # $1: variable to check
3387 
3388 
3389 # Check that there are no unprocessed overridden variables left.
3390 # If so, they are an incorrect argument and we will exit with an error.
3391 
3392 
3393 # Setup a tool for the given variable. If correctly specified by the user,
3394 # use that value, otherwise search for the tool using the supplied code snippet.
3395 # $1: variable to set
3396 # $2: code snippet to call to look for the tool
3397 
3398 
3399 # Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
3400 # $1: variable to set
3401 # $2: executable name (or list of names) to look for
3402 
3403 
3404 # Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
3405 # $1: variable to set
3406 # $2: executable name (or list of names) to look for
3407 
3408 
3409 # Like BASIC_PATH_PROGS but fails if no tool was found.
3410 # $1: variable to set
3411 # $2: executable name (or list of names) to look for
3412 
3413 
3414 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3415 # $1: variable to set
3416 # $2: autoconf macro to call to look for the special tool
3417 
3418 
3419 # Setup the most fundamental tools that relies on not much else to set up,
3420 # but is used by much of the early bootstrap code.
3421 
3422 
3423 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3424 
3425 
3426 
3427 
3428 
3429 
3430 
3431 
3432 
3433 #%%% Simple tools %%%
3434 
3435 # Check if we have found a usable version of make
3436 # $1: the path to a potential make binary (or empty)
3437 # $2: the description on how we found this
3438 
3439 
3440 # Goes looking for a usable version of GNU make.
3441 
3442 
3443 
3444 
3445 
3446 
3447 # Check if build directory is on local disk. If not possible to determine,
3448 # we prefer to claim it's local.
3449 # Argument 1: directory to test
3450 # Argument 2: what to do if it is on local disk
3451 # Argument 3: what to do otherwise (remote disk or failure)
3452 
3453 
3454 # Check that source files have basic read permissions set. This might
3455 # not be the case in cygwin in certain conditions.
3456 
3457 
3458 
3459 
3460 #
3461 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3462 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3463 #
3464 # This code is free software; you can redistribute it and/or modify it
3465 # under the terms of the GNU General Public License version 2 only, as
3466 # published by the Free Software Foundation.  Oracle designates this
3467 # particular file as subject to the "Classpath" exception as provided
3468 # by Oracle in the LICENSE file that accompanied this code.
3469 #
3470 # This code is distributed in the hope that it will be useful, but WITHOUT
3471 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3472 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3473 # version 2 for more details (a copy is included in the LICENSE file that
3474 # accompanied this code).
3475 #
3476 # You should have received a copy of the GNU General Public License version
3477 # 2 along with this work; if not, write to the Free Software Foundation,
3478 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3479 #
3480 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3481 # or visit www.oracle.com if you need additional information or have any
3482 # questions.
3483 #
3484 
3485 
3486 
3487 
3488 
3489 # Helper function which possibly converts a path using DOS-style short mode.
3490 # If so, the updated path is stored in $new_path.
3491 # $1: The path to check
3492 
3493 
3494 # Helper function which possibly converts a path using DOS-style short mode.
3495 # If so, the updated path is stored in $new_path.
3496 # $1: The path to check
3497 
3498 
3499 # FIXME: The BASIC_FIXUP_*_CYGWIN/MSYS is most likely too convoluted
3500 # and could probably be heavily simplified. However, all changes in this
3501 # area tend to need lot of testing in different scenarios, and in lack of
3502 # proper unit testing, cleaning this up has not been deemed worth the effort
3503 # at the moment.
3504 
3505 
3506 
3507 
3508 
3509 
3510 
3511 
3512 
3513 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3514 
3515 
3516 
3517 
3518 #
3519 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3520 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3521 #
3522 # This code is free software; you can redistribute it and/or modify it
3523 # under the terms of the GNU General Public License version 2 only, as
3524 # published by the Free Software Foundation.  Oracle designates this
3525 # particular file as subject to the "Classpath" exception as provided
3526 # by Oracle in the LICENSE file that accompanied this code.
3527 #
3528 # This code is distributed in the hope that it will be useful, but WITHOUT
3529 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3530 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3531 # version 2 for more details (a copy is included in the LICENSE file that
3532 # accompanied this code).
3533 #
3534 # You should have received a copy of the GNU General Public License version
3535 # 2 along with this work; if not, write to the Free Software Foundation,
3536 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3537 #
3538 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3539 # or visit www.oracle.com if you need additional information or have any
3540 # questions.
3541 #
3542 
3543 
3544 
3545 
3546 
3547 
3548 
3549 
3550 
3551 
3552 
3553 # ... then the rest
3554 #
3555 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3556 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3557 #
3558 # This code is free software; you can redistribute it and/or modify it
3559 # under the terms of the GNU General Public License version 2 only, as
3560 # published by the Free Software Foundation.  Oracle designates this
3561 # particular file as subject to the "Classpath" exception as provided
3562 # by Oracle in the LICENSE file that accompanied this code.
3563 #
3564 # This code is distributed in the hope that it will be useful, but WITHOUT
3565 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3566 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3567 # version 2 for more details (a copy is included in the LICENSE file that
3568 # accompanied this code).
3569 #
3570 # You should have received a copy of the GNU General Public License version
3571 # 2 along with this work; if not, write to the Free Software Foundation,
3572 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3573 #
3574 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3575 # or visit www.oracle.com if you need additional information or have any
3576 # questions.
3577 #
3578 
3579 ########################################################################
3580 # This file handles detection of the Boot JDK. The Boot JDK detection
3581 # process has been developed as a response to solve a complex real-world
3582 # problem. Initially, it was simple, but it has grown as platform after
3583 # platform, idiosyncracy after idiosyncracy has been supported.
3584 #
3585 # The basic idea is this:
3586 # 1) You need an acceptable *) JDK to use as a Boot JDK
3587 # 2) There are several ways to locate a JDK, that are mostly platform
3588 #    dependent **)
3589 # 3) You can have multiple JDKs installed
3590 # 4) If possible, configure should try to dig out an acceptable JDK
3591 #    automatically, without having to resort to command-line options
3592 #
3593 # *)  acceptable means e.g. JDK7 for building JDK8, a complete JDK (with
3594 #     javac) and not a JRE, etc.
3595 #
3596 # **) On Windows we typically use a well-known path.
3597 #     On MacOSX we typically use the tool java_home.
3598 #     On Linux we typically find javac in the $PATH, and then follow a
3599 #     chain of symlinks that often ends up in a real JDK.
3600 #
3601 # This leads to the code where we check in different ways to locate a
3602 # JDK, and if one is found, check if it is acceptable. If not, we print
3603 # our reasons for rejecting it (useful when debugging non-working
3604 # configure situations) and continue checking the next one.
3605 ########################################################################
3606 
3607 # Execute the check given as argument, and verify the result
3608 # If the Boot JDK was previously found, do nothing
3609 # $1 A command line (typically autoconf macro) to execute
3610 
3611 
3612 # Test: Is bootjdk explicitely set by command line arguments?
3613 
3614 
3615 # Test: Is bootjdk available from builddeps?
3616 
3617 
3618 # Test: Is $JAVA_HOME set?
3619 
3620 
3621 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
3622 
3623 
3624 # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
3625 # $1: Argument to the java_home binary (optional)
3626 
3627 
3628 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
3629 
3630 
3631 # Look for a jdk in the given path. If there are multiple, try to select the newest.
3632 # If found, set BOOT_JDK and BOOT_JDK_FOUND.
3633 # $1 = Path to directory containing jdk installations.
3634 # $2 = String to append to the found JDK directory to get the proper JDK home
3635 
3636 
3637 # Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
3638 # environmental variable as base for where to look.
3639 # $1 Name of an environmal variable, assumed to point to the Program Files directory.
3640 
3641 
3642 # Test: Is there a JDK installed in default, well-known locations?
3643 
3644 
3645 # Check that a command-line tool in the Boot JDK is correct
3646 # $1 = name of variable to assign
3647 # $2 = name of binary
3648 
3649 
3650 ###############################################################################
3651 #
3652 # We need a Boot JDK to bootstrap the build.
3653 #
3654 
3655 
3656 
3657 
3658 
3659 #
3660 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3661 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3662 #
3663 # This code is free software; you can redistribute it and/or modify it
3664 # under the terms of the GNU General Public License version 2 only, as
3665 # published by the Free Software Foundation.  Oracle designates this
3666 # particular file as subject to the "Classpath" exception as provided
3667 # by Oracle in the LICENSE file that accompanied this code.
3668 #
3669 # This code is distributed in the hope that it will be useful, but WITHOUT
3670 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3671 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3672 # version 2 for more details (a copy is included in the LICENSE file that
3673 # accompanied this code).
3674 #
3675 # You should have received a copy of the GNU General Public License version
3676 # 2 along with this work; if not, write to the Free Software Foundation,
3677 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3678 #
3679 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3680 # or visit www.oracle.com if you need additional information or have any
3681 # questions.
3682 #
3683 
3684 
3685 
3686 
3687 
3688 
3689 
3690 
3691 
3692 
3693 
3694 
3695 
3696 
3697 
3698 
3699 
3700 
3701 
3702 
3703 #
3704 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3705 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3706 #
3707 # This code is free software; you can redistribute it and/or modify it
3708 # under the terms of the GNU General Public License version 2 only, as
3709 # published by the Free Software Foundation.  Oracle designates this
3710 # particular file as subject to the "Classpath" exception as provided
3711 # by Oracle in the LICENSE file that accompanied this code.
3712 #
3713 # This code is distributed in the hope that it will be useful, but WITHOUT
3714 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3715 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3716 # version 2 for more details (a copy is included in the LICENSE file that
3717 # accompanied this code).
3718 #
3719 # You should have received a copy of the GNU General Public License version
3720 # 2 along with this work; if not, write to the Free Software Foundation,
3721 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3722 #
3723 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3724 # or visit www.oracle.com if you need additional information or have any
3725 # questions.
3726 #
3727 
3728 
3729 
3730 
3731 
3732 # Documentation on common flags used for solstudio in HIGHEST.
3733 #
3734 # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
3735 #          done with care, there are some assumptions below that need to
3736 #          be understood about the use of pointers, and IEEE behavior.
3737 #
3738 # -fns: Use non-standard floating point mode (not IEEE 754)
3739 # -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)
3740 # -fsingle: Use single precision floating point with 'float'
3741 # -xalias_level=basic: Assume memory references via basic pointer types do not alias
3742 #   (Source with excessing pointer casting and data access with mixed
3743 #    pointer types are not recommended)
3744 # -xbuiltin=%all: Use intrinsic or inline versions for math/std functions
3745 #   (If you expect perfect errno behavior, do not use this)
3746 # -xdepend: Loop data dependency optimizations (need -xO3 or higher)
3747 # -xrestrict: Pointer parameters to functions do not overlap
3748 #   (Similar to -xalias_level=basic usage, but less obvious sometimes.
3749 #    If you pass in multiple pointers to the same data, do not use this)
3750 # -xlibmil: Inline some library routines
3751 #   (If you expect perfect errno behavior, do not use this)
3752 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
3753 #   (If you expect perfect errno behavior, do not use this)
3754 #  Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
3755 
3756     # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
3757     # Bug?
3758     #if test "x$OPENJDK_TARGET_CPU" = xsparc; then
3759     #  CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
3760     #  CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
3761     #fi
3762 
3763 
3764 
3765 
3766 
3767 
3768 # FLAGS_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3769 #                                   [RUN-IF-FALSE])
3770 # ------------------------------------------------------------
3771 # Check that the c and c++ compilers support an argument
3772 
3773 
3774 
3775 
3776 #
3777 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3778 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3779 #
3780 # This code is free software; you can redistribute it and/or modify it
3781 # under the terms of the GNU General Public License version 2 only, as
3782 # published by the Free Software Foundation.  Oracle designates this
3783 # particular file as subject to the "Classpath" exception as provided
3784 # by Oracle in the LICENSE file that accompanied this code.
3785 #
3786 # This code is distributed in the hope that it will be useful, but WITHOUT
3787 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3788 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3789 # version 2 for more details (a copy is included in the LICENSE file that
3790 # accompanied this code).
3791 #
3792 # You should have received a copy of the GNU General Public License version
3793 # 2 along with this work; if not, write to the Free Software Foundation,
3794 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3795 #
3796 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3797 # or visit www.oracle.com if you need additional information or have any
3798 # questions.
3799 #
3800 
3801 
3802 
3803 
3804 
3805 cygwin_help() {
3806   case $1 in
3807     unzip)
3808       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P unzip )"
3809       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3810       ;;
3811     zip)
3812       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P zip )"
3813       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3814       ;;
3815     make)
3816       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P make )"
3817       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3818       ;;
3819     freetype)
3820       if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
3821         HELP_MSG="To install freetype, run:
3822 wget \"http://gnuwin32.sourceforge.net/downlinks/freetype.php\" -O /tmp/freetype-setup.exe
3823 chmod +x /tmp/freetype-setup.exe
3824 /tmp/freetype-setup.exe
3825 Follow GUI prompts, and install to default directory \"C:\Program Files (x86)\GnuWin32\".
3826 After installation, locate lib/libfreetype.dll.a and make a copy with the name freetype.dll."
3827       else
3828         HELP_MSG="You need to build a 64-bit version of freetype.
3829 This is not readily available.
3830 You can find source code and build instructions on
3831 http://www.freetype.org/
3832 If you put the resulting build in \"C:\Program Files\GnuWin32\", it will be found automatically."
3833       fi
3834       ;;
3835   esac
3836 }
3837 
3838 msys_help() {
3839   PKGHANDLER_COMMAND=""
3840 }
3841 
3842 apt_help() {
3843   case $1 in
3844     devkit)
3845       PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;;
3846     openjdk)
3847       PKGHANDLER_COMMAND="sudo apt-get install openjdk-7-jdk" ;;
3848     alsa)
3849       PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;;
3850     cups)
3851       PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;;
3852     freetype)
3853       PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;;
3854     pulse)
3855       PKGHANDLER_COMMAND="sudo apt-get install libpulse-dev" ;;
3856     x11)
3857       PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
3858     ccache)
3859       PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
3860   esac
3861 }
3862 
3863 yum_help() {
3864   case $1 in
3865     devkit)
3866       PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;;
3867     openjdk)
3868       PKGHANDLER_COMMAND="sudo yum install java-1.7.0-openjdk" ;;
3869     alsa)
3870       PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;;
3871     cups)
3872       PKGHANDLER_COMMAND="sudo yum install cups-devel" ;;
3873     freetype)
3874       PKGHANDLER_COMMAND="sudo yum install freetype-devel" ;;
3875     pulse)
3876       PKGHANDLER_COMMAND="sudo yum install pulseaudio-libs-devel" ;;
3877     x11)
3878       PKGHANDLER_COMMAND="sudo yum install libXtst-devel libXt-devel libXrender-devel" ;;
3879     ccache)
3880       PKGHANDLER_COMMAND="sudo yum install ccache" ;;
3881   esac
3882 }
3883 
3884 port_help() {
3885   PKGHANDLER_COMMAND=""
3886 }
3887 
3888 pkgutil_help() {
3889   PKGHANDLER_COMMAND=""
3890 }
3891 
3892 pkgadd_help() {
3893   PKGHANDLER_COMMAND=""
3894 }
3895 
3896 # This function will check if we're called from the "configure" wrapper while
3897 # printing --help. If so, we will print out additional information that can
3898 # only be extracted within the autoconf script, and then exit. This must be
3899 # called at the very beginning in configure.ac.
3900 
3901 
3902 
3903 
3904 #
3905 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3906 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3907 #
3908 # This code is free software; you can redistribute it and/or modify it
3909 # under the terms of the GNU General Public License version 2 only, as
3910 # published by the Free Software Foundation.  Oracle designates this
3911 # particular file as subject to the "Classpath" exception as provided
3912 # by Oracle in the LICENSE file that accompanied this code.
3913 #
3914 # This code is distributed in the hope that it will be useful, but WITHOUT
3915 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3916 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3917 # version 2 for more details (a copy is included in the LICENSE file that
3918 # accompanied this code).
3919 #
3920 # You should have received a copy of the GNU General Public License version
3921 # 2 along with this work; if not, write to the Free Software Foundation,
3922 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3923 #
3924 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3925 # or visit www.oracle.com if you need additional information or have any
3926 # questions.
3927 #
3928 
3929 
3930 
3931 
3932 
3933 
3934 
3935 
3936 
3937 
3938 ###############################################################################
3939 #
3940 # Should we build only OpenJDK even if closed sources are present?
3941 #
3942 
3943 
3944 
3945 
3946 ###############################################################################
3947 #
3948 # Setup version numbers
3949 #
3950 
3951 
3952 
3953 
3954 
3955 
3956 #
3957 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3958 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3959 #
3960 # This code is free software; you can redistribute it and/or modify it
3961 # under the terms of the GNU General Public License version 2 only, as
3962 # published by the Free Software Foundation.  Oracle designates this
3963 # particular file as subject to the "Classpath" exception as provided
3964 # by Oracle in the LICENSE file that accompanied this code.
3965 #
3966 # This code is distributed in the hope that it will be useful, but WITHOUT
3967 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3968 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3969 # version 2 for more details (a copy is included in the LICENSE file that
3970 # accompanied this code).
3971 #
3972 # You should have received a copy of the GNU General Public License version
3973 # 2 along with this work; if not, write to the Free Software Foundation,
3974 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3975 #
3976 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3977 # or visit www.oracle.com if you need additional information or have any
3978 # questions.
3979 #
3980 
3981 
3982 
3983 
3984 
3985 
3986 
3987 
3988 
3989 
3990 
3991 
3992 
3993 
3994 
3995 
3996 
3997 
3998 
3999 #
4000 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4001 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4002 #
4003 # This code is free software; you can redistribute it and/or modify it
4004 # under the terms of the GNU General Public License version 2 only, as
4005 # published by the Free Software Foundation.  Oracle designates this
4006 # particular file as subject to the "Classpath" exception as provided
4007 # by Oracle in the LICENSE file that accompanied this code.
4008 #
4009 # This code is distributed in the hope that it will be useful, but WITHOUT
4010 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4011 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4012 # version 2 for more details (a copy is included in the LICENSE file that
4013 # accompanied this code).
4014 #
4015 # You should have received a copy of the GNU General Public License version
4016 # 2 along with this work; if not, write to the Free Software Foundation,
4017 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4018 #
4019 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4020 # or visit www.oracle.com if you need additional information or have any
4021 # questions.
4022 #
4023 
4024 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4025 # Converts autoconf style CPU name to OpenJDK style, into
4026 # VAR_CPU, VAR_CPU_ARCH, VAR_CPU_BITS and VAR_CPU_ENDIAN.
4027 
4028 
4029 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4030 # Converts autoconf style OS name to OpenJDK style, into
4031 # VAR_OS and VAR_OS_API.
4032 
4033 
4034 # Expects $host_os $host_cpu $build_os and $build_cpu
4035 # and $with_target_bits to have been setup!
4036 #
4037 # Translate the standard triplet(quadruplet) definition
4038 # of the target/build system into OPENJDK_TARGET_OS, OPENJDK_TARGET_CPU,
4039 # OPENJDK_BUILD_OS, etc.
4040 
4041 
4042 # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
4043 # accordingly. Must be done after setting up build and target system, but before
4044 # doing anything else with these values.
4045 
4046 
4047 # Setup the legacy variables, for controlling the old makefiles.
4048 #
4049 
4050 
4051 
4052 
4053 #%%% Build and target systems %%%
4054 
4055 
4056 
4057 
4058 # Support macro for PLATFORM_SETUP_OPENJDK_TARGET_BITS.
4059 # Add -mX to various FLAGS variables.
4060 
4061 
4062 
4063 
4064 
4065 
4066 #
4067 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4068 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4069 #
4070 # This code is free software; you can redistribute it and/or modify it
4071 # under the terms of the GNU General Public License version 2 only, as
4072 # published by the Free Software Foundation.  Oracle designates this
4073 # particular file as subject to the "Classpath" exception as provided
4074 # by Oracle in the LICENSE file that accompanied this code.
4075 #
4076 # This code is distributed in the hope that it will be useful, but WITHOUT
4077 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4078 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4079 # version 2 for more details (a copy is included in the LICENSE file that
4080 # accompanied this code).
4081 #
4082 # You should have received a copy of the GNU General Public License version
4083 # 2 along with this work; if not, write to the Free Software Foundation,
4084 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4085 #
4086 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4087 # or visit www.oracle.com if you need additional information or have any
4088 # questions.
4089 #
4090 
4091 
4092 
4093 
4094 
4095 
4096 
4097 
4098 #
4099 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
4100 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4101 #
4102 # This code is free software; you can redistribute it and/or modify it
4103 # under the terms of the GNU General Public License version 2 only, as
4104 # published by the Free Software Foundation.  Oracle designates this
4105 # particular file as subject to the "Classpath" exception as provided
4106 # by Oracle in the LICENSE file that accompanied this code.
4107 #
4108 # This code is distributed in the hope that it will be useful, but WITHOUT
4109 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4110 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4111 # version 2 for more details (a copy is included in the LICENSE file that
4112 # accompanied this code).
4113 #
4114 # You should have received a copy of the GNU General Public License version
4115 # 2 along with this work; if not, write to the Free Software Foundation,
4116 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4117 #
4118 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4119 # or visit www.oracle.com if you need additional information or have any
4120 # questions.
4121 #
4122 
4123 ########################################################################
4124 # This file is responsible for detecting, verifying and setting up the
4125 # toolchain, i.e. the compiler, linker and related utilities. It will setup
4126 # proper paths to the binaries, but it will not setup any flags.
4127 #
4128 # The binaries used is determined by the toolchain type, which is the family of
4129 # compilers and related tools that are used.
4130 ########################################################################
4131 
4132 
4133 # All valid toolchains, regardless of platform (used by help.m4)
4134 VALID_TOOLCHAINS_all="gcc clang solstudio xlc microsoft"
4135 
4136 # These toolchains are valid on different platforms
4137 VALID_TOOLCHAINS_linux="gcc clang"
4138 VALID_TOOLCHAINS_solaris="solstudio"
4139 VALID_TOOLCHAINS_macosx="gcc clang"
4140 VALID_TOOLCHAINS_aix="xlc"
4141 VALID_TOOLCHAINS_windows="microsoft"
4142 
4143 # Toolchain descriptions
4144 TOOLCHAIN_DESCRIPTION_clang="clang/LLVM"
4145 TOOLCHAIN_DESCRIPTION_gcc="GNU Compiler Collection"
4146 TOOLCHAIN_DESCRIPTION_microsoft="Microsoft Visual Studio"
4147 TOOLCHAIN_DESCRIPTION_solstudio="Oracle Solaris Studio"
4148 TOOLCHAIN_DESCRIPTION_xlc="IBM XL C/C++"
4149 
4150 # Setup a number of variables describing how native output files are
4151 # named on this platform/toolchain.
4152 
4153 
4154 # Determine which toolchain type to use, and make sure it is valid for this
4155 # platform. Setup various information about the selected toolchain.
4156 
4157 
4158 # Before we start detecting the toolchain executables, we might need some
4159 # special setup, e.g. additional paths etc.
4160 
4161 
4162 # Restore path, etc
4163 
4164 
4165 # Check if a compiler is of the toolchain type we expect, and save the version
4166 # information from it. If the compiler does not match the expected type,
4167 # this function will abort using AC_MSG_ERROR. If it matches, the version will
4168 # be stored in CC_VERSION_NUMBER/CXX_VERSION_NUMBER (as a dotted number), and
4169 # the full version string in CC_VERSION_STRING/CXX_VERSION_STRING.
4170 #
4171 # $1 = compiler to test (CC or CXX)
4172 # $2 = human readable name of compiler (C or C++)
4173 
4174 
4175 # Try to locate the given C or C++ compiler in the path, or otherwise.
4176 #
4177 # $1 = compiler to test (CC or CXX)
4178 # $2 = human readable name of compiler (C or C++)
4179 # $3 = list of compiler names to search for
4180 
4181 
4182 # Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
4183 # preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
4184 # archiver (AR). Verify that the compilers are correct according to the
4185 # toolchain type.
4186 
4187 
4188 # Setup additional tools that is considered a part of the toolchain, but not the
4189 # core part. Many of these are highly platform-specific and do not exist,
4190 # and/or are not needed on all platforms.
4191 
4192 
4193 # Setup the build tools (i.e, the compiler and linker used to build programs
4194 # that should be run on the build platform, not the target platform, as a build
4195 # helper). Since the non-cross-compile case uses the normal, target compilers
4196 # for this, we can only do this after these have been setup.
4197 
4198 
4199 # Setup legacy variables that are still needed as alternative ways to refer to
4200 # parts of the toolchain.
4201 
4202 
4203 # Do some additional checks on the detected tools.
4204 
4205 
4206 # Setup the JTReg Regression Test Harness.
4207 
4208 
4209 #
4210 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4211 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4212 #
4213 # This code is free software; you can redistribute it and/or modify it
4214 # under the terms of the GNU General Public License version 2 only, as
4215 # published by the Free Software Foundation.  Oracle designates this
4216 # particular file as subject to the "Classpath" exception as provided
4217 # by Oracle in the LICENSE file that accompanied this code.
4218 #
4219 # This code is distributed in the hope that it will be useful, but WITHOUT
4220 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4221 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4222 # version 2 for more details (a copy is included in the LICENSE file that
4223 # accompanied this code).
4224 #
4225 # You should have received a copy of the GNU General Public License version
4226 # 2 along with this work; if not, write to the Free Software Foundation,
4227 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4228 #
4229 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4230 # or visit www.oracle.com if you need additional information or have any
4231 # questions.
4232 #
4233 
4234 
4235 
4236 
4237 
4238 
4239 
4240 # Check if the VS env variables were setup prior to running configure.
4241 # If not, then find vcvarsall.bat and run it automatically, and integrate
4242 # the set env variables into the spec file.
4243 
4244 
4245 
4246 
4247 
4248 
4249 
4250 
4251 
4252 
4253 # This line needs to be here, verbatim, after all includes and the dummy hook
4254 # definitions. It is replaced with custom functionality when building
4255 # custom sources.
4256 #CUSTOM_AUTOCONF_INCLUDE
4257 
4258 # Do not change or remove the following line, it is needed for consistency checks:
4259 DATE_WHEN_GENERATED=1400279335
4260 
4261 ###############################################################################
4262 #
4263 # Initialization / Boot-strapping
4264 #
4265 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4266 # thus it jumps back and forth, each time gaining something needed later on.
4267 #
4268 ###############################################################################
4269 
4270 # If we are requested to print additional help, do that and then exit.
4271 # This must be the very first call.
4272 
4273   if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4274     $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4275     $PRINTF "Which are valid to use depends on the build platform.\n"
4276     for toolchain in $VALID_TOOLCHAINS_all; do
4277       # Use indirect variable referencing
4278       toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4279       TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
4280       $PRINTF "  %-10s  %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
4281     done
4282 
4283     # And now exit directly
4284     exit 0
4285   fi
4286 
4287 
4288 # Basic initialization that must happen first of all in the normal process.
4289 
4290   # Save the original command line. This is passed to us by the wrapper configure script.
4291 
4292   DATE_WHEN_CONFIGURED=`LANG=C date`
4293 
4294   { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
4295 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
4296   { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
4297 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
4298 
4299 
4300   # Start with tools that do not need have cross compilation support
4301   # and can be expected to be found in the default PATH. These tools are
4302   # used by configure. Nor are these tools expected to be found in the
4303   # devkit from the builddeps server either, since they are
4304   # needed to download the devkit.
4305 
4306   # First are all the simple required tools.
4307 
4308 
4309 
4310   # Publish this variable in the help.
4311 
4312 
4313   if test "x$BASENAME" = x; then
4314     # The variable is not set by user, try to locate tool using the code snippet
4315     for ac_prog in basename
4316 do
4317   # Extract the first word of "$ac_prog", so it can be a program name with args.
4318 set dummy $ac_prog; ac_word=$2
4319 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4320 $as_echo_n "checking for $ac_word... " >&6; }
4321 if ${ac_cv_path_BASENAME+:} false; then :
4322   $as_echo_n "(cached) " >&6
4323 else
4324   case $BASENAME in
4325   [\\/]* | ?:[\\/]*)
4326   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4327   ;;
4328   *)
4329   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4330 for as_dir in $PATH
4331 do
4332   IFS=$as_save_IFS
4333   test -z "$as_dir" && as_dir=.
4334     for ac_exec_ext in '' $ac_executable_extensions; do
4335   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4336     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4337     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4338     break 2
4339   fi
4340 done
4341   done
4342 IFS=$as_save_IFS
4343 
4344   ;;
4345 esac
4346 fi
4347 BASENAME=$ac_cv_path_BASENAME
4348 if test -n "$BASENAME"; then
4349   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4350 $as_echo "$BASENAME" >&6; }
4351 else
4352   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4353 $as_echo "no" >&6; }
4354 fi
4355 
4356 
4357   test -n "$BASENAME" && break
4358 done
4359 
4360   else
4361     # The variable is set, but is it from the command line or the environment?
4362 
4363     # Try to remove the string !BASENAME! from our list.
4364     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
4365     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4366       # If it failed, the variable was not from the command line. Ignore it,
4367       # but warn the user (except for BASH, which is always set by the calling BASH).
4368       if test "xBASENAME" != xBASH; then
4369         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
4370 $as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
4371       fi
4372       # Try to locate tool using the code snippet
4373       for ac_prog in basename
4374 do
4375   # Extract the first word of "$ac_prog", so it can be a program name with args.
4376 set dummy $ac_prog; ac_word=$2
4377 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4378 $as_echo_n "checking for $ac_word... " >&6; }
4379 if ${ac_cv_path_BASENAME+:} false; then :
4380   $as_echo_n "(cached) " >&6
4381 else
4382   case $BASENAME in
4383   [\\/]* | ?:[\\/]*)
4384   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4385   ;;
4386   *)
4387   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4388 for as_dir in $PATH
4389 do
4390   IFS=$as_save_IFS
4391   test -z "$as_dir" && as_dir=.
4392     for ac_exec_ext in '' $ac_executable_extensions; do
4393   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4394     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4395     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4396     break 2
4397   fi
4398 done
4399   done
4400 IFS=$as_save_IFS
4401 
4402   ;;
4403 esac
4404 fi
4405 BASENAME=$ac_cv_path_BASENAME
4406 if test -n "$BASENAME"; then
4407   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4408 $as_echo "$BASENAME" >&6; }
4409 else
4410   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4411 $as_echo "no" >&6; }
4412 fi
4413 
4414 
4415   test -n "$BASENAME" && break
4416 done
4417 
4418     else
4419       # If it succeeded, then it was overridden by the user. We will use it
4420       # for the tool.
4421 
4422       # First remove it from the list of overridden variables, so we can test
4423       # for unknown variables in the end.
4424       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4425 
4426       # Check if the provided tool contains a complete path.
4427       tool_specified="$BASENAME"
4428       tool_basename="${tool_specified##*/}"
4429       if test "x$tool_basename" = "x$tool_specified"; then
4430         # A command without a complete path is provided, search $PATH.
4431         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
4432 $as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
4433         # Extract the first word of "$tool_basename", so it can be a program name with args.
4434 set dummy $tool_basename; ac_word=$2
4435 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4436 $as_echo_n "checking for $ac_word... " >&6; }
4437 if ${ac_cv_path_BASENAME+:} false; then :
4438   $as_echo_n "(cached) " >&6
4439 else
4440   case $BASENAME in
4441   [\\/]* | ?:[\\/]*)
4442   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4443   ;;
4444   *)
4445   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4446 for as_dir in $PATH
4447 do
4448   IFS=$as_save_IFS
4449   test -z "$as_dir" && as_dir=.
4450     for ac_exec_ext in '' $ac_executable_extensions; do
4451   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4452     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4453     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4454     break 2
4455   fi
4456 done
4457   done
4458 IFS=$as_save_IFS
4459 
4460   ;;
4461 esac
4462 fi
4463 BASENAME=$ac_cv_path_BASENAME
4464 if test -n "$BASENAME"; then
4465   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4466 $as_echo "$BASENAME" >&6; }
4467 else
4468   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4469 $as_echo "no" >&6; }
4470 fi
4471 
4472 
4473         if test "x$BASENAME" = x; then
4474           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4475         fi
4476       else
4477         # Otherwise we believe it is a complete path. Use it as it is.
4478         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
4479 $as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
4480         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
4481 $as_echo_n "checking for BASENAME... " >&6; }
4482         if test ! -x "$tool_specified"; then
4483           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4484 $as_echo "not found" >&6; }
4485           as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
4486         fi
4487         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4488 $as_echo "$tool_specified" >&6; }
4489       fi
4490     fi
4491   fi
4492 
4493 
4494 
4495   if test "x$BASENAME" = x; then
4496     as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
4497   fi
4498 
4499 
4500 
4501 
4502 
4503   # Publish this variable in the help.
4504 
4505 
4506   if test "x$BASH" = x; then
4507     # The variable is not set by user, try to locate tool using the code snippet
4508     for ac_prog in bash
4509 do
4510   # Extract the first word of "$ac_prog", so it can be a program name with args.
4511 set dummy $ac_prog; ac_word=$2
4512 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4513 $as_echo_n "checking for $ac_word... " >&6; }
4514 if ${ac_cv_path_BASH+:} false; then :
4515   $as_echo_n "(cached) " >&6
4516 else
4517   case $BASH in
4518   [\\/]* | ?:[\\/]*)
4519   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4520   ;;
4521   *)
4522   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4523 for as_dir in $PATH
4524 do
4525   IFS=$as_save_IFS
4526   test -z "$as_dir" && as_dir=.
4527     for ac_exec_ext in '' $ac_executable_extensions; do
4528   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4529     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4530     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4531     break 2
4532   fi
4533 done
4534   done
4535 IFS=$as_save_IFS
4536 
4537   ;;
4538 esac
4539 fi
4540 BASH=$ac_cv_path_BASH
4541 if test -n "$BASH"; then
4542   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4543 $as_echo "$BASH" >&6; }
4544 else
4545   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4546 $as_echo "no" >&6; }
4547 fi
4548 
4549 
4550   test -n "$BASH" && break
4551 done
4552 
4553   else
4554     # The variable is set, but is it from the command line or the environment?
4555 
4556     # Try to remove the string !BASH! from our list.
4557     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
4558     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4559       # If it failed, the variable was not from the command line. Ignore it,
4560       # but warn the user (except for BASH, which is always set by the calling BASH).
4561       if test "xBASH" != xBASH; then
4562         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
4563 $as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
4564       fi
4565       # Try to locate tool using the code snippet
4566       for ac_prog in bash
4567 do
4568   # Extract the first word of "$ac_prog", so it can be a program name with args.
4569 set dummy $ac_prog; ac_word=$2
4570 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4571 $as_echo_n "checking for $ac_word... " >&6; }
4572 if ${ac_cv_path_BASH+:} false; then :
4573   $as_echo_n "(cached) " >&6
4574 else
4575   case $BASH in
4576   [\\/]* | ?:[\\/]*)
4577   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4578   ;;
4579   *)
4580   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4581 for as_dir in $PATH
4582 do
4583   IFS=$as_save_IFS
4584   test -z "$as_dir" && as_dir=.
4585     for ac_exec_ext in '' $ac_executable_extensions; do
4586   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4587     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4588     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4589     break 2
4590   fi
4591 done
4592   done
4593 IFS=$as_save_IFS
4594 
4595   ;;
4596 esac
4597 fi
4598 BASH=$ac_cv_path_BASH
4599 if test -n "$BASH"; then
4600   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4601 $as_echo "$BASH" >&6; }
4602 else
4603   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4604 $as_echo "no" >&6; }
4605 fi
4606 
4607 
4608   test -n "$BASH" && break
4609 done
4610 
4611     else
4612       # If it succeeded, then it was overridden by the user. We will use it
4613       # for the tool.
4614 
4615       # First remove it from the list of overridden variables, so we can test
4616       # for unknown variables in the end.
4617       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4618 
4619       # Check if the provided tool contains a complete path.
4620       tool_specified="$BASH"
4621       tool_basename="${tool_specified##*/}"
4622       if test "x$tool_basename" = "x$tool_specified"; then
4623         # A command without a complete path is provided, search $PATH.
4624         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
4625 $as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
4626         # Extract the first word of "$tool_basename", so it can be a program name with args.
4627 set dummy $tool_basename; ac_word=$2
4628 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4629 $as_echo_n "checking for $ac_word... " >&6; }
4630 if ${ac_cv_path_BASH+:} false; then :
4631   $as_echo_n "(cached) " >&6
4632 else
4633   case $BASH in
4634   [\\/]* | ?:[\\/]*)
4635   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4636   ;;
4637   *)
4638   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4639 for as_dir in $PATH
4640 do
4641   IFS=$as_save_IFS
4642   test -z "$as_dir" && as_dir=.
4643     for ac_exec_ext in '' $ac_executable_extensions; do
4644   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4645     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4646     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4647     break 2
4648   fi
4649 done
4650   done
4651 IFS=$as_save_IFS
4652 
4653   ;;
4654 esac
4655 fi
4656 BASH=$ac_cv_path_BASH
4657 if test -n "$BASH"; then
4658   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4659 $as_echo "$BASH" >&6; }
4660 else
4661   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4662 $as_echo "no" >&6; }
4663 fi
4664 
4665 
4666         if test "x$BASH" = x; then
4667           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4668         fi
4669       else
4670         # Otherwise we believe it is a complete path. Use it as it is.
4671         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
4672 $as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
4673         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
4674 $as_echo_n "checking for BASH... " >&6; }
4675         if test ! -x "$tool_specified"; then
4676           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4677 $as_echo "not found" >&6; }
4678           as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
4679         fi
4680         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4681 $as_echo "$tool_specified" >&6; }
4682       fi
4683     fi
4684   fi
4685 
4686 
4687 
4688   if test "x$BASH" = x; then
4689     as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
4690   fi
4691 
4692 
4693 
4694 
4695 
4696   # Publish this variable in the help.
4697 
4698 
4699   if test "x$CAT" = x; then
4700     # The variable is not set by user, try to locate tool using the code snippet
4701     for ac_prog in cat
4702 do
4703   # Extract the first word of "$ac_prog", so it can be a program name with args.
4704 set dummy $ac_prog; ac_word=$2
4705 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4706 $as_echo_n "checking for $ac_word... " >&6; }
4707 if ${ac_cv_path_CAT+:} false; then :
4708   $as_echo_n "(cached) " >&6
4709 else
4710   case $CAT in
4711   [\\/]* | ?:[\\/]*)
4712   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4713   ;;
4714   *)
4715   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4716 for as_dir in $PATH
4717 do
4718   IFS=$as_save_IFS
4719   test -z "$as_dir" && as_dir=.
4720     for ac_exec_ext in '' $ac_executable_extensions; do
4721   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4722     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4723     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4724     break 2
4725   fi
4726 done
4727   done
4728 IFS=$as_save_IFS
4729 
4730   ;;
4731 esac
4732 fi
4733 CAT=$ac_cv_path_CAT
4734 if test -n "$CAT"; then
4735   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4736 $as_echo "$CAT" >&6; }
4737 else
4738   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4739 $as_echo "no" >&6; }
4740 fi
4741 
4742 
4743   test -n "$CAT" && break
4744 done
4745 
4746   else
4747     # The variable is set, but is it from the command line or the environment?
4748 
4749     # Try to remove the string !CAT! from our list.
4750     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
4751     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4752       # If it failed, the variable was not from the command line. Ignore it,
4753       # but warn the user (except for BASH, which is always set by the calling BASH).
4754       if test "xCAT" != xBASH; then
4755         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
4756 $as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
4757       fi
4758       # Try to locate tool using the code snippet
4759       for ac_prog in cat
4760 do
4761   # Extract the first word of "$ac_prog", so it can be a program name with args.
4762 set dummy $ac_prog; ac_word=$2
4763 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4764 $as_echo_n "checking for $ac_word... " >&6; }
4765 if ${ac_cv_path_CAT+:} false; then :
4766   $as_echo_n "(cached) " >&6
4767 else
4768   case $CAT in
4769   [\\/]* | ?:[\\/]*)
4770   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4771   ;;
4772   *)
4773   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4774 for as_dir in $PATH
4775 do
4776   IFS=$as_save_IFS
4777   test -z "$as_dir" && as_dir=.
4778     for ac_exec_ext in '' $ac_executable_extensions; do
4779   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4780     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4781     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4782     break 2
4783   fi
4784 done
4785   done
4786 IFS=$as_save_IFS
4787 
4788   ;;
4789 esac
4790 fi
4791 CAT=$ac_cv_path_CAT
4792 if test -n "$CAT"; then
4793   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4794 $as_echo "$CAT" >&6; }
4795 else
4796   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4797 $as_echo "no" >&6; }
4798 fi
4799 
4800 
4801   test -n "$CAT" && break
4802 done
4803 
4804     else
4805       # If it succeeded, then it was overridden by the user. We will use it
4806       # for the tool.
4807 
4808       # First remove it from the list of overridden variables, so we can test
4809       # for unknown variables in the end.
4810       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4811 
4812       # Check if the provided tool contains a complete path.
4813       tool_specified="$CAT"
4814       tool_basename="${tool_specified##*/}"
4815       if test "x$tool_basename" = "x$tool_specified"; then
4816         # A command without a complete path is provided, search $PATH.
4817         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
4818 $as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
4819         # Extract the first word of "$tool_basename", so it can be a program name with args.
4820 set dummy $tool_basename; ac_word=$2
4821 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4822 $as_echo_n "checking for $ac_word... " >&6; }
4823 if ${ac_cv_path_CAT+:} false; then :
4824   $as_echo_n "(cached) " >&6
4825 else
4826   case $CAT in
4827   [\\/]* | ?:[\\/]*)
4828   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4829   ;;
4830   *)
4831   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4832 for as_dir in $PATH
4833 do
4834   IFS=$as_save_IFS
4835   test -z "$as_dir" && as_dir=.
4836     for ac_exec_ext in '' $ac_executable_extensions; do
4837   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4838     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4839     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4840     break 2
4841   fi
4842 done
4843   done
4844 IFS=$as_save_IFS
4845 
4846   ;;
4847 esac
4848 fi
4849 CAT=$ac_cv_path_CAT
4850 if test -n "$CAT"; then
4851   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4852 $as_echo "$CAT" >&6; }
4853 else
4854   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4855 $as_echo "no" >&6; }
4856 fi
4857 
4858 
4859         if test "x$CAT" = x; then
4860           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4861         fi
4862       else
4863         # Otherwise we believe it is a complete path. Use it as it is.
4864         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
4865 $as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
4866         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
4867 $as_echo_n "checking for CAT... " >&6; }
4868         if test ! -x "$tool_specified"; then
4869           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4870 $as_echo "not found" >&6; }
4871           as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
4872         fi
4873         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4874 $as_echo "$tool_specified" >&6; }
4875       fi
4876     fi
4877   fi
4878 
4879 
4880 
4881   if test "x$CAT" = x; then
4882     as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
4883   fi
4884 
4885 
4886 
4887 
4888 
4889   # Publish this variable in the help.
4890 
4891 
4892   if test "x$CHMOD" = x; then
4893     # The variable is not set by user, try to locate tool using the code snippet
4894     for ac_prog in chmod
4895 do
4896   # Extract the first word of "$ac_prog", so it can be a program name with args.
4897 set dummy $ac_prog; ac_word=$2
4898 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4899 $as_echo_n "checking for $ac_word... " >&6; }
4900 if ${ac_cv_path_CHMOD+:} false; then :
4901   $as_echo_n "(cached) " >&6
4902 else
4903   case $CHMOD in
4904   [\\/]* | ?:[\\/]*)
4905   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
4906   ;;
4907   *)
4908   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4909 for as_dir in $PATH
4910 do
4911   IFS=$as_save_IFS
4912   test -z "$as_dir" && as_dir=.
4913     for ac_exec_ext in '' $ac_executable_extensions; do
4914   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4915     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
4916     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4917     break 2
4918   fi
4919 done
4920   done
4921 IFS=$as_save_IFS
4922 
4923   ;;
4924 esac
4925 fi
4926 CHMOD=$ac_cv_path_CHMOD
4927 if test -n "$CHMOD"; then
4928   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
4929 $as_echo "$CHMOD" >&6; }
4930 else
4931   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4932 $as_echo "no" >&6; }
4933 fi
4934 
4935 
4936   test -n "$CHMOD" && break
4937 done
4938 
4939   else
4940     # The variable is set, but is it from the command line or the environment?
4941 
4942     # Try to remove the string !CHMOD! from our list.
4943     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
4944     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4945       # If it failed, the variable was not from the command line. Ignore it,
4946       # but warn the user (except for BASH, which is always set by the calling BASH).
4947       if test "xCHMOD" != xBASH; then
4948         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
4949 $as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
4950       fi
4951       # Try to locate tool using the code snippet
4952       for ac_prog in chmod
4953 do
4954   # Extract the first word of "$ac_prog", so it can be a program name with args.
4955 set dummy $ac_prog; ac_word=$2
4956 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4957 $as_echo_n "checking for $ac_word... " >&6; }
4958 if ${ac_cv_path_CHMOD+:} false; then :
4959   $as_echo_n "(cached) " >&6
4960 else
4961   case $CHMOD in
4962   [\\/]* | ?:[\\/]*)
4963   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
4964   ;;
4965   *)
4966   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4967 for as_dir in $PATH
4968 do
4969   IFS=$as_save_IFS
4970   test -z "$as_dir" && as_dir=.
4971     for ac_exec_ext in '' $ac_executable_extensions; do
4972   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4973     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
4974     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4975     break 2
4976   fi
4977 done
4978   done
4979 IFS=$as_save_IFS
4980 
4981   ;;
4982 esac
4983 fi
4984 CHMOD=$ac_cv_path_CHMOD
4985 if test -n "$CHMOD"; then
4986   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
4987 $as_echo "$CHMOD" >&6; }
4988 else
4989   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4990 $as_echo "no" >&6; }
4991 fi
4992 
4993 
4994   test -n "$CHMOD" && break
4995 done
4996 
4997     else
4998       # If it succeeded, then it was overridden by the user. We will use it
4999       # for the tool.
5000 
5001       # First remove it from the list of overridden variables, so we can test
5002       # for unknown variables in the end.
5003       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5004 
5005       # Check if the provided tool contains a complete path.
5006       tool_specified="$CHMOD"
5007       tool_basename="${tool_specified##*/}"
5008       if test "x$tool_basename" = "x$tool_specified"; then
5009         # A command without a complete path is provided, search $PATH.
5010         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
5011 $as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
5012         # Extract the first word of "$tool_basename", so it can be a program name with args.
5013 set dummy $tool_basename; ac_word=$2
5014 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5015 $as_echo_n "checking for $ac_word... " >&6; }
5016 if ${ac_cv_path_CHMOD+:} false; then :
5017   $as_echo_n "(cached) " >&6
5018 else
5019   case $CHMOD in
5020   [\\/]* | ?:[\\/]*)
5021   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5022   ;;
5023   *)
5024   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5025 for as_dir in $PATH
5026 do
5027   IFS=$as_save_IFS
5028   test -z "$as_dir" && as_dir=.
5029     for ac_exec_ext in '' $ac_executable_extensions; do
5030   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5031     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5032     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5033     break 2
5034   fi
5035 done
5036   done
5037 IFS=$as_save_IFS
5038 
5039   ;;
5040 esac
5041 fi
5042 CHMOD=$ac_cv_path_CHMOD
5043 if test -n "$CHMOD"; then
5044   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5045 $as_echo "$CHMOD" >&6; }
5046 else
5047   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5048 $as_echo "no" >&6; }
5049 fi
5050 
5051 
5052         if test "x$CHMOD" = x; then
5053           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5054         fi
5055       else
5056         # Otherwise we believe it is a complete path. Use it as it is.
5057         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
5058 $as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
5059         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5060 $as_echo_n "checking for CHMOD... " >&6; }
5061         if test ! -x "$tool_specified"; then
5062           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5063 $as_echo "not found" >&6; }
5064           as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
5065         fi
5066         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5067 $as_echo "$tool_specified" >&6; }
5068       fi
5069     fi
5070   fi
5071 
5072 
5073 
5074   if test "x$CHMOD" = x; then
5075     as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
5076   fi
5077 
5078 
5079 
5080 
5081 
5082   # Publish this variable in the help.
5083 
5084 
5085   if test "x$CMP" = x; then
5086     # The variable is not set by user, try to locate tool using the code snippet
5087     for ac_prog in cmp
5088 do
5089   # Extract the first word of "$ac_prog", so it can be a program name with args.
5090 set dummy $ac_prog; ac_word=$2
5091 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5092 $as_echo_n "checking for $ac_word... " >&6; }
5093 if ${ac_cv_path_CMP+:} false; then :
5094   $as_echo_n "(cached) " >&6
5095 else
5096   case $CMP in
5097   [\\/]* | ?:[\\/]*)
5098   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5099   ;;
5100   *)
5101   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5102 for as_dir in $PATH
5103 do
5104   IFS=$as_save_IFS
5105   test -z "$as_dir" && as_dir=.
5106     for ac_exec_ext in '' $ac_executable_extensions; do
5107   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5108     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5109     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5110     break 2
5111   fi
5112 done
5113   done
5114 IFS=$as_save_IFS
5115 
5116   ;;
5117 esac
5118 fi
5119 CMP=$ac_cv_path_CMP
5120 if test -n "$CMP"; then
5121   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5122 $as_echo "$CMP" >&6; }
5123 else
5124   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5125 $as_echo "no" >&6; }
5126 fi
5127 
5128 
5129   test -n "$CMP" && break
5130 done
5131 
5132   else
5133     # The variable is set, but is it from the command line or the environment?
5134 
5135     # Try to remove the string !CMP! from our list.
5136     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
5137     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5138       # If it failed, the variable was not from the command line. Ignore it,
5139       # but warn the user (except for BASH, which is always set by the calling BASH).
5140       if test "xCMP" != xBASH; then
5141         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
5142 $as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
5143       fi
5144       # Try to locate tool using the code snippet
5145       for ac_prog in cmp
5146 do
5147   # Extract the first word of "$ac_prog", so it can be a program name with args.
5148 set dummy $ac_prog; ac_word=$2
5149 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5150 $as_echo_n "checking for $ac_word... " >&6; }
5151 if ${ac_cv_path_CMP+:} false; then :
5152   $as_echo_n "(cached) " >&6
5153 else
5154   case $CMP in
5155   [\\/]* | ?:[\\/]*)
5156   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5157   ;;
5158   *)
5159   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5160 for as_dir in $PATH
5161 do
5162   IFS=$as_save_IFS
5163   test -z "$as_dir" && as_dir=.
5164     for ac_exec_ext in '' $ac_executable_extensions; do
5165   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5166     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5167     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5168     break 2
5169   fi
5170 done
5171   done
5172 IFS=$as_save_IFS
5173 
5174   ;;
5175 esac
5176 fi
5177 CMP=$ac_cv_path_CMP
5178 if test -n "$CMP"; then
5179   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5180 $as_echo "$CMP" >&6; }
5181 else
5182   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5183 $as_echo "no" >&6; }
5184 fi
5185 
5186 
5187   test -n "$CMP" && break
5188 done
5189 
5190     else
5191       # If it succeeded, then it was overridden by the user. We will use it
5192       # for the tool.
5193 
5194       # First remove it from the list of overridden variables, so we can test
5195       # for unknown variables in the end.
5196       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5197 
5198       # Check if the provided tool contains a complete path.
5199       tool_specified="$CMP"
5200       tool_basename="${tool_specified##*/}"
5201       if test "x$tool_basename" = "x$tool_specified"; then
5202         # A command without a complete path is provided, search $PATH.
5203         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
5204 $as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
5205         # Extract the first word of "$tool_basename", so it can be a program name with args.
5206 set dummy $tool_basename; ac_word=$2
5207 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5208 $as_echo_n "checking for $ac_word... " >&6; }
5209 if ${ac_cv_path_CMP+:} false; then :
5210   $as_echo_n "(cached) " >&6
5211 else
5212   case $CMP in
5213   [\\/]* | ?:[\\/]*)
5214   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5215   ;;
5216   *)
5217   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5218 for as_dir in $PATH
5219 do
5220   IFS=$as_save_IFS
5221   test -z "$as_dir" && as_dir=.
5222     for ac_exec_ext in '' $ac_executable_extensions; do
5223   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5224     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5225     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5226     break 2
5227   fi
5228 done
5229   done
5230 IFS=$as_save_IFS
5231 
5232   ;;
5233 esac
5234 fi
5235 CMP=$ac_cv_path_CMP
5236 if test -n "$CMP"; then
5237   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5238 $as_echo "$CMP" >&6; }
5239 else
5240   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5241 $as_echo "no" >&6; }
5242 fi
5243 
5244 
5245         if test "x$CMP" = x; then
5246           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5247         fi
5248       else
5249         # Otherwise we believe it is a complete path. Use it as it is.
5250         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
5251 $as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
5252         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
5253 $as_echo_n "checking for CMP... " >&6; }
5254         if test ! -x "$tool_specified"; then
5255           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5256 $as_echo "not found" >&6; }
5257           as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
5258         fi
5259         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5260 $as_echo "$tool_specified" >&6; }
5261       fi
5262     fi
5263   fi
5264 
5265 
5266 
5267   if test "x$CMP" = x; then
5268     as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
5269   fi
5270 
5271 
5272 
5273 
5274 
5275   # Publish this variable in the help.
5276 
5277 
5278   if test "x$COMM" = x; then
5279     # The variable is not set by user, try to locate tool using the code snippet
5280     for ac_prog in comm
5281 do
5282   # Extract the first word of "$ac_prog", so it can be a program name with args.
5283 set dummy $ac_prog; ac_word=$2
5284 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5285 $as_echo_n "checking for $ac_word... " >&6; }
5286 if ${ac_cv_path_COMM+:} false; then :
5287   $as_echo_n "(cached) " >&6
5288 else
5289   case $COMM in
5290   [\\/]* | ?:[\\/]*)
5291   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5292   ;;
5293   *)
5294   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5295 for as_dir in $PATH
5296 do
5297   IFS=$as_save_IFS
5298   test -z "$as_dir" && as_dir=.
5299     for ac_exec_ext in '' $ac_executable_extensions; do
5300   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5301     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5302     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5303     break 2
5304   fi
5305 done
5306   done
5307 IFS=$as_save_IFS
5308 
5309   ;;
5310 esac
5311 fi
5312 COMM=$ac_cv_path_COMM
5313 if test -n "$COMM"; then
5314   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5315 $as_echo "$COMM" >&6; }
5316 else
5317   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5318 $as_echo "no" >&6; }
5319 fi
5320 
5321 
5322   test -n "$COMM" && break
5323 done
5324 
5325   else
5326     # The variable is set, but is it from the command line or the environment?
5327 
5328     # Try to remove the string !COMM! from our list.
5329     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
5330     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5331       # If it failed, the variable was not from the command line. Ignore it,
5332       # but warn the user (except for BASH, which is always set by the calling BASH).
5333       if test "xCOMM" != xBASH; then
5334         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
5335 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
5336       fi
5337       # Try to locate tool using the code snippet
5338       for ac_prog in comm
5339 do
5340   # Extract the first word of "$ac_prog", so it can be a program name with args.
5341 set dummy $ac_prog; ac_word=$2
5342 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5343 $as_echo_n "checking for $ac_word... " >&6; }
5344 if ${ac_cv_path_COMM+:} false; then :
5345   $as_echo_n "(cached) " >&6
5346 else
5347   case $COMM in
5348   [\\/]* | ?:[\\/]*)
5349   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5350   ;;
5351   *)
5352   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5353 for as_dir in $PATH
5354 do
5355   IFS=$as_save_IFS
5356   test -z "$as_dir" && as_dir=.
5357     for ac_exec_ext in '' $ac_executable_extensions; do
5358   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5359     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5360     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5361     break 2
5362   fi
5363 done
5364   done
5365 IFS=$as_save_IFS
5366 
5367   ;;
5368 esac
5369 fi
5370 COMM=$ac_cv_path_COMM
5371 if test -n "$COMM"; then
5372   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5373 $as_echo "$COMM" >&6; }
5374 else
5375   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5376 $as_echo "no" >&6; }
5377 fi
5378 
5379 
5380   test -n "$COMM" && break
5381 done
5382 
5383     else
5384       # If it succeeded, then it was overridden by the user. We will use it
5385       # for the tool.
5386 
5387       # First remove it from the list of overridden variables, so we can test
5388       # for unknown variables in the end.
5389       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5390 
5391       # Check if the provided tool contains a complete path.
5392       tool_specified="$COMM"
5393       tool_basename="${tool_specified##*/}"
5394       if test "x$tool_basename" = "x$tool_specified"; then
5395         # A command without a complete path is provided, search $PATH.
5396         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
5397 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
5398         # Extract the first word of "$tool_basename", so it can be a program name with args.
5399 set dummy $tool_basename; ac_word=$2
5400 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5401 $as_echo_n "checking for $ac_word... " >&6; }
5402 if ${ac_cv_path_COMM+:} false; then :
5403   $as_echo_n "(cached) " >&6
5404 else
5405   case $COMM in
5406   [\\/]* | ?:[\\/]*)
5407   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5408   ;;
5409   *)
5410   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5411 for as_dir in $PATH
5412 do
5413   IFS=$as_save_IFS
5414   test -z "$as_dir" && as_dir=.
5415     for ac_exec_ext in '' $ac_executable_extensions; do
5416   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5417     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5418     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5419     break 2
5420   fi
5421 done
5422   done
5423 IFS=$as_save_IFS
5424 
5425   ;;
5426 esac
5427 fi
5428 COMM=$ac_cv_path_COMM
5429 if test -n "$COMM"; then
5430   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5431 $as_echo "$COMM" >&6; }
5432 else
5433   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5434 $as_echo "no" >&6; }
5435 fi
5436 
5437 
5438         if test "x$COMM" = x; then
5439           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5440         fi
5441       else
5442         # Otherwise we believe it is a complete path. Use it as it is.
5443         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
5444 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
5445         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
5446 $as_echo_n "checking for COMM... " >&6; }
5447         if test ! -x "$tool_specified"; then
5448           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5449 $as_echo "not found" >&6; }
5450           as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
5451         fi
5452         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5453 $as_echo "$tool_specified" >&6; }
5454       fi
5455     fi
5456   fi
5457 
5458 
5459 
5460   if test "x$COMM" = x; then
5461     as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
5462   fi
5463 
5464 
5465 
5466 
5467 
5468   # Publish this variable in the help.
5469 
5470 
5471   if test "x$CP" = x; then
5472     # The variable is not set by user, try to locate tool using the code snippet
5473     for ac_prog in cp
5474 do
5475   # Extract the first word of "$ac_prog", so it can be a program name with args.
5476 set dummy $ac_prog; ac_word=$2
5477 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5478 $as_echo_n "checking for $ac_word... " >&6; }
5479 if ${ac_cv_path_CP+:} false; then :
5480   $as_echo_n "(cached) " >&6
5481 else
5482   case $CP in
5483   [\\/]* | ?:[\\/]*)
5484   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5485   ;;
5486   *)
5487   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5488 for as_dir in $PATH
5489 do
5490   IFS=$as_save_IFS
5491   test -z "$as_dir" && as_dir=.
5492     for ac_exec_ext in '' $ac_executable_extensions; do
5493   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5494     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5495     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5496     break 2
5497   fi
5498 done
5499   done
5500 IFS=$as_save_IFS
5501 
5502   ;;
5503 esac
5504 fi
5505 CP=$ac_cv_path_CP
5506 if test -n "$CP"; then
5507   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5508 $as_echo "$CP" >&6; }
5509 else
5510   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5511 $as_echo "no" >&6; }
5512 fi
5513 
5514 
5515   test -n "$CP" && break
5516 done
5517 
5518   else
5519     # The variable is set, but is it from the command line or the environment?
5520 
5521     # Try to remove the string !CP! from our list.
5522     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
5523     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5524       # If it failed, the variable was not from the command line. Ignore it,
5525       # but warn the user (except for BASH, which is always set by the calling BASH).
5526       if test "xCP" != xBASH; then
5527         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
5528 $as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
5529       fi
5530       # Try to locate tool using the code snippet
5531       for ac_prog in cp
5532 do
5533   # Extract the first word of "$ac_prog", so it can be a program name with args.
5534 set dummy $ac_prog; ac_word=$2
5535 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5536 $as_echo_n "checking for $ac_word... " >&6; }
5537 if ${ac_cv_path_CP+:} false; then :
5538   $as_echo_n "(cached) " >&6
5539 else
5540   case $CP in
5541   [\\/]* | ?:[\\/]*)
5542   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5543   ;;
5544   *)
5545   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5546 for as_dir in $PATH
5547 do
5548   IFS=$as_save_IFS
5549   test -z "$as_dir" && as_dir=.
5550     for ac_exec_ext in '' $ac_executable_extensions; do
5551   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5552     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5553     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5554     break 2
5555   fi
5556 done
5557   done
5558 IFS=$as_save_IFS
5559 
5560   ;;
5561 esac
5562 fi
5563 CP=$ac_cv_path_CP
5564 if test -n "$CP"; then
5565   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5566 $as_echo "$CP" >&6; }
5567 else
5568   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5569 $as_echo "no" >&6; }
5570 fi
5571 
5572 
5573   test -n "$CP" && break
5574 done
5575 
5576     else
5577       # If it succeeded, then it was overridden by the user. We will use it
5578       # for the tool.
5579 
5580       # First remove it from the list of overridden variables, so we can test
5581       # for unknown variables in the end.
5582       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5583 
5584       # Check if the provided tool contains a complete path.
5585       tool_specified="$CP"
5586       tool_basename="${tool_specified##*/}"
5587       if test "x$tool_basename" = "x$tool_specified"; then
5588         # A command without a complete path is provided, search $PATH.
5589         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
5590 $as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
5591         # Extract the first word of "$tool_basename", so it can be a program name with args.
5592 set dummy $tool_basename; ac_word=$2
5593 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5594 $as_echo_n "checking for $ac_word... " >&6; }
5595 if ${ac_cv_path_CP+:} false; then :
5596   $as_echo_n "(cached) " >&6
5597 else
5598   case $CP in
5599   [\\/]* | ?:[\\/]*)
5600   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5601   ;;
5602   *)
5603   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5604 for as_dir in $PATH
5605 do
5606   IFS=$as_save_IFS
5607   test -z "$as_dir" && as_dir=.
5608     for ac_exec_ext in '' $ac_executable_extensions; do
5609   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5610     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5611     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5612     break 2
5613   fi
5614 done
5615   done
5616 IFS=$as_save_IFS
5617 
5618   ;;
5619 esac
5620 fi
5621 CP=$ac_cv_path_CP
5622 if test -n "$CP"; then
5623   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5624 $as_echo "$CP" >&6; }
5625 else
5626   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5627 $as_echo "no" >&6; }
5628 fi
5629 
5630 
5631         if test "x$CP" = x; then
5632           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5633         fi
5634       else
5635         # Otherwise we believe it is a complete path. Use it as it is.
5636         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
5637 $as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
5638         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
5639 $as_echo_n "checking for CP... " >&6; }
5640         if test ! -x "$tool_specified"; then
5641           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5642 $as_echo "not found" >&6; }
5643           as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
5644         fi
5645         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5646 $as_echo "$tool_specified" >&6; }
5647       fi
5648     fi
5649   fi
5650 
5651 
5652 
5653   if test "x$CP" = x; then
5654     as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
5655   fi
5656 
5657 
5658 
5659 
5660 
5661   # Publish this variable in the help.
5662 
5663 
5664   if test "x$CPIO" = x; then
5665     # The variable is not set by user, try to locate tool using the code snippet
5666     for ac_prog in cpio
5667 do
5668   # Extract the first word of "$ac_prog", so it can be a program name with args.
5669 set dummy $ac_prog; ac_word=$2
5670 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5671 $as_echo_n "checking for $ac_word... " >&6; }
5672 if ${ac_cv_path_CPIO+:} false; then :
5673   $as_echo_n "(cached) " >&6
5674 else
5675   case $CPIO in
5676   [\\/]* | ?:[\\/]*)
5677   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
5678   ;;
5679   *)
5680   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5681 for as_dir in $PATH
5682 do
5683   IFS=$as_save_IFS
5684   test -z "$as_dir" && as_dir=.
5685     for ac_exec_ext in '' $ac_executable_extensions; do
5686   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5687     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
5688     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5689     break 2
5690   fi
5691 done
5692   done
5693 IFS=$as_save_IFS
5694 
5695   ;;
5696 esac
5697 fi
5698 CPIO=$ac_cv_path_CPIO
5699 if test -n "$CPIO"; then
5700   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
5701 $as_echo "$CPIO" >&6; }
5702 else
5703   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5704 $as_echo "no" >&6; }
5705 fi
5706 
5707 
5708   test -n "$CPIO" && break
5709 done
5710 
5711   else
5712     # The variable is set, but is it from the command line or the environment?
5713 
5714     # Try to remove the string !CPIO! from our list.
5715     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
5716     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5717       # If it failed, the variable was not from the command line. Ignore it,
5718       # but warn the user (except for BASH, which is always set by the calling BASH).
5719       if test "xCPIO" != xBASH; then
5720         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
5721 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
5722       fi
5723       # Try to locate tool using the code snippet
5724       for ac_prog in cpio
5725 do
5726   # Extract the first word of "$ac_prog", so it can be a program name with args.
5727 set dummy $ac_prog; ac_word=$2
5728 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5729 $as_echo_n "checking for $ac_word... " >&6; }
5730 if ${ac_cv_path_CPIO+:} false; then :
5731   $as_echo_n "(cached) " >&6
5732 else
5733   case $CPIO in
5734   [\\/]* | ?:[\\/]*)
5735   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
5736   ;;
5737   *)
5738   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5739 for as_dir in $PATH
5740 do
5741   IFS=$as_save_IFS
5742   test -z "$as_dir" && as_dir=.
5743     for ac_exec_ext in '' $ac_executable_extensions; do
5744   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5745     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
5746     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5747     break 2
5748   fi
5749 done
5750   done
5751 IFS=$as_save_IFS
5752 
5753   ;;
5754 esac
5755 fi
5756 CPIO=$ac_cv_path_CPIO
5757 if test -n "$CPIO"; then
5758   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
5759 $as_echo "$CPIO" >&6; }
5760 else
5761   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5762 $as_echo "no" >&6; }
5763 fi
5764 
5765 
5766   test -n "$CPIO" && break
5767 done
5768 
5769     else
5770       # If it succeeded, then it was overridden by the user. We will use it
5771       # for the tool.
5772 
5773       # First remove it from the list of overridden variables, so we can test
5774       # for unknown variables in the end.
5775       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5776 
5777       # Check if the provided tool contains a complete path.
5778       tool_specified="$CPIO"
5779       tool_basename="${tool_specified##*/}"
5780       if test "x$tool_basename" = "x$tool_specified"; then
5781         # A command without a complete path is provided, search $PATH.
5782         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
5783 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
5784         # Extract the first word of "$tool_basename", so it can be a program name with args.
5785 set dummy $tool_basename; ac_word=$2
5786 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5787 $as_echo_n "checking for $ac_word... " >&6; }
5788 if ${ac_cv_path_CPIO+:} false; then :
5789   $as_echo_n "(cached) " >&6
5790 else
5791   case $CPIO in
5792   [\\/]* | ?:[\\/]*)
5793   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
5794   ;;
5795   *)
5796   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5797 for as_dir in $PATH
5798 do
5799   IFS=$as_save_IFS
5800   test -z "$as_dir" && as_dir=.
5801     for ac_exec_ext in '' $ac_executable_extensions; do
5802   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5803     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
5804     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5805     break 2
5806   fi
5807 done
5808   done
5809 IFS=$as_save_IFS
5810 
5811   ;;
5812 esac
5813 fi
5814 CPIO=$ac_cv_path_CPIO
5815 if test -n "$CPIO"; then
5816   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
5817 $as_echo "$CPIO" >&6; }
5818 else
5819   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5820 $as_echo "no" >&6; }
5821 fi
5822 
5823 
5824         if test "x$CPIO" = x; then
5825           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5826         fi
5827       else
5828         # Otherwise we believe it is a complete path. Use it as it is.
5829         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
5830 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
5831         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
5832 $as_echo_n "checking for CPIO... " >&6; }
5833         if test ! -x "$tool_specified"; then
5834           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5835 $as_echo "not found" >&6; }
5836           as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
5837         fi
5838         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5839 $as_echo "$tool_specified" >&6; }
5840       fi
5841     fi
5842   fi
5843 
5844 
5845 
5846   if test "x$CPIO" = x; then
5847     as_fn_error $? "Could not find required tool for CPIO" "$LINENO" 5
5848   fi
5849 
5850 
5851 
5852 
5853 
5854   # Publish this variable in the help.
5855 
5856 
5857   if test "x$CUT" = x; then
5858     # The variable is not set by user, try to locate tool using the code snippet
5859     for ac_prog in cut
5860 do
5861   # Extract the first word of "$ac_prog", so it can be a program name with args.
5862 set dummy $ac_prog; ac_word=$2
5863 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5864 $as_echo_n "checking for $ac_word... " >&6; }
5865 if ${ac_cv_path_CUT+:} false; then :
5866   $as_echo_n "(cached) " >&6
5867 else
5868   case $CUT in
5869   [\\/]* | ?:[\\/]*)
5870   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5871   ;;
5872   *)
5873   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5874 for as_dir in $PATH
5875 do
5876   IFS=$as_save_IFS
5877   test -z "$as_dir" && as_dir=.
5878     for ac_exec_ext in '' $ac_executable_extensions; do
5879   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5880     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5881     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5882     break 2
5883   fi
5884 done
5885   done
5886 IFS=$as_save_IFS
5887 
5888   ;;
5889 esac
5890 fi
5891 CUT=$ac_cv_path_CUT
5892 if test -n "$CUT"; then
5893   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5894 $as_echo "$CUT" >&6; }
5895 else
5896   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5897 $as_echo "no" >&6; }
5898 fi
5899 
5900 
5901   test -n "$CUT" && break
5902 done
5903 
5904   else
5905     # The variable is set, but is it from the command line or the environment?
5906 
5907     # Try to remove the string !CUT! from our list.
5908     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
5909     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5910       # If it failed, the variable was not from the command line. Ignore it,
5911       # but warn the user (except for BASH, which is always set by the calling BASH).
5912       if test "xCUT" != xBASH; then
5913         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
5914 $as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
5915       fi
5916       # Try to locate tool using the code snippet
5917       for ac_prog in cut
5918 do
5919   # Extract the first word of "$ac_prog", so it can be a program name with args.
5920 set dummy $ac_prog; ac_word=$2
5921 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5922 $as_echo_n "checking for $ac_word... " >&6; }
5923 if ${ac_cv_path_CUT+:} false; then :
5924   $as_echo_n "(cached) " >&6
5925 else
5926   case $CUT in
5927   [\\/]* | ?:[\\/]*)
5928   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5929   ;;
5930   *)
5931   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5932 for as_dir in $PATH
5933 do
5934   IFS=$as_save_IFS
5935   test -z "$as_dir" && as_dir=.
5936     for ac_exec_ext in '' $ac_executable_extensions; do
5937   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5938     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5939     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5940     break 2
5941   fi
5942 done
5943   done
5944 IFS=$as_save_IFS
5945 
5946   ;;
5947 esac
5948 fi
5949 CUT=$ac_cv_path_CUT
5950 if test -n "$CUT"; then
5951   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5952 $as_echo "$CUT" >&6; }
5953 else
5954   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5955 $as_echo "no" >&6; }
5956 fi
5957 
5958 
5959   test -n "$CUT" && break
5960 done
5961 
5962     else
5963       # If it succeeded, then it was overridden by the user. We will use it
5964       # for the tool.
5965 
5966       # First remove it from the list of overridden variables, so we can test
5967       # for unknown variables in the end.
5968       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5969 
5970       # Check if the provided tool contains a complete path.
5971       tool_specified="$CUT"
5972       tool_basename="${tool_specified##*/}"
5973       if test "x$tool_basename" = "x$tool_specified"; then
5974         # A command without a complete path is provided, search $PATH.
5975         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
5976 $as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
5977         # Extract the first word of "$tool_basename", so it can be a program name with args.
5978 set dummy $tool_basename; ac_word=$2
5979 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5980 $as_echo_n "checking for $ac_word... " >&6; }
5981 if ${ac_cv_path_CUT+:} false; then :
5982   $as_echo_n "(cached) " >&6
5983 else
5984   case $CUT in
5985   [\\/]* | ?:[\\/]*)
5986   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5987   ;;
5988   *)
5989   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5990 for as_dir in $PATH
5991 do
5992   IFS=$as_save_IFS
5993   test -z "$as_dir" && as_dir=.
5994     for ac_exec_ext in '' $ac_executable_extensions; do
5995   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5996     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5997     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5998     break 2
5999   fi
6000 done
6001   done
6002 IFS=$as_save_IFS
6003 
6004   ;;
6005 esac
6006 fi
6007 CUT=$ac_cv_path_CUT
6008 if test -n "$CUT"; then
6009   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
6010 $as_echo "$CUT" >&6; }
6011 else
6012   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6013 $as_echo "no" >&6; }
6014 fi
6015 
6016 
6017         if test "x$CUT" = x; then
6018           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6019         fi
6020       else
6021         # Otherwise we believe it is a complete path. Use it as it is.
6022         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
6023 $as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
6024         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
6025 $as_echo_n "checking for CUT... " >&6; }
6026         if test ! -x "$tool_specified"; then
6027           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6028 $as_echo "not found" >&6; }
6029           as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
6030         fi
6031         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6032 $as_echo "$tool_specified" >&6; }
6033       fi
6034     fi
6035   fi
6036 
6037 
6038 
6039   if test "x$CUT" = x; then
6040     as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
6041   fi
6042 
6043 
6044 
6045 
6046 
6047   # Publish this variable in the help.
6048 
6049 
6050   if test "x$DATE" = x; then
6051     # The variable is not set by user, try to locate tool using the code snippet
6052     for ac_prog in date
6053 do
6054   # Extract the first word of "$ac_prog", so it can be a program name with args.
6055 set dummy $ac_prog; ac_word=$2
6056 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6057 $as_echo_n "checking for $ac_word... " >&6; }
6058 if ${ac_cv_path_DATE+:} false; then :
6059   $as_echo_n "(cached) " >&6
6060 else
6061   case $DATE in
6062   [\\/]* | ?:[\\/]*)
6063   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6064   ;;
6065   *)
6066   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6067 for as_dir in $PATH
6068 do
6069   IFS=$as_save_IFS
6070   test -z "$as_dir" && as_dir=.
6071     for ac_exec_ext in '' $ac_executable_extensions; do
6072   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6073     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6074     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6075     break 2
6076   fi
6077 done
6078   done
6079 IFS=$as_save_IFS
6080 
6081   ;;
6082 esac
6083 fi
6084 DATE=$ac_cv_path_DATE
6085 if test -n "$DATE"; then
6086   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6087 $as_echo "$DATE" >&6; }
6088 else
6089   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6090 $as_echo "no" >&6; }
6091 fi
6092 
6093 
6094   test -n "$DATE" && break
6095 done
6096 
6097   else
6098     # The variable is set, but is it from the command line or the environment?
6099 
6100     # Try to remove the string !DATE! from our list.
6101     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
6102     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6103       # If it failed, the variable was not from the command line. Ignore it,
6104       # but warn the user (except for BASH, which is always set by the calling BASH).
6105       if test "xDATE" != xBASH; then
6106         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
6107 $as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
6108       fi
6109       # Try to locate tool using the code snippet
6110       for ac_prog in date
6111 do
6112   # Extract the first word of "$ac_prog", so it can be a program name with args.
6113 set dummy $ac_prog; ac_word=$2
6114 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6115 $as_echo_n "checking for $ac_word... " >&6; }
6116 if ${ac_cv_path_DATE+:} false; then :
6117   $as_echo_n "(cached) " >&6
6118 else
6119   case $DATE in
6120   [\\/]* | ?:[\\/]*)
6121   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6122   ;;
6123   *)
6124   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6125 for as_dir in $PATH
6126 do
6127   IFS=$as_save_IFS
6128   test -z "$as_dir" && as_dir=.
6129     for ac_exec_ext in '' $ac_executable_extensions; do
6130   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6131     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6132     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6133     break 2
6134   fi
6135 done
6136   done
6137 IFS=$as_save_IFS
6138 
6139   ;;
6140 esac
6141 fi
6142 DATE=$ac_cv_path_DATE
6143 if test -n "$DATE"; then
6144   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6145 $as_echo "$DATE" >&6; }
6146 else
6147   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6148 $as_echo "no" >&6; }
6149 fi
6150 
6151 
6152   test -n "$DATE" && break
6153 done
6154 
6155     else
6156       # If it succeeded, then it was overridden by the user. We will use it
6157       # for the tool.
6158 
6159       # First remove it from the list of overridden variables, so we can test
6160       # for unknown variables in the end.
6161       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6162 
6163       # Check if the provided tool contains a complete path.
6164       tool_specified="$DATE"
6165       tool_basename="${tool_specified##*/}"
6166       if test "x$tool_basename" = "x$tool_specified"; then
6167         # A command without a complete path is provided, search $PATH.
6168         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
6169 $as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
6170         # Extract the first word of "$tool_basename", so it can be a program name with args.
6171 set dummy $tool_basename; ac_word=$2
6172 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6173 $as_echo_n "checking for $ac_word... " >&6; }
6174 if ${ac_cv_path_DATE+:} false; then :
6175   $as_echo_n "(cached) " >&6
6176 else
6177   case $DATE in
6178   [\\/]* | ?:[\\/]*)
6179   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6180   ;;
6181   *)
6182   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6183 for as_dir in $PATH
6184 do
6185   IFS=$as_save_IFS
6186   test -z "$as_dir" && as_dir=.
6187     for ac_exec_ext in '' $ac_executable_extensions; do
6188   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6189     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6190     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6191     break 2
6192   fi
6193 done
6194   done
6195 IFS=$as_save_IFS
6196 
6197   ;;
6198 esac
6199 fi
6200 DATE=$ac_cv_path_DATE
6201 if test -n "$DATE"; then
6202   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6203 $as_echo "$DATE" >&6; }
6204 else
6205   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6206 $as_echo "no" >&6; }
6207 fi
6208 
6209 
6210         if test "x$DATE" = x; then
6211           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6212         fi
6213       else
6214         # Otherwise we believe it is a complete path. Use it as it is.
6215         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
6216 $as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
6217         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6218 $as_echo_n "checking for DATE... " >&6; }
6219         if test ! -x "$tool_specified"; then
6220           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6221 $as_echo "not found" >&6; }
6222           as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
6223         fi
6224         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6225 $as_echo "$tool_specified" >&6; }
6226       fi
6227     fi
6228   fi
6229 
6230 
6231 
6232   if test "x$DATE" = x; then
6233     as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
6234   fi
6235 
6236 
6237 
6238 
6239 
6240   # Publish this variable in the help.
6241 
6242 
6243   if test "x$DIFF" = x; then
6244     # The variable is not set by user, try to locate tool using the code snippet
6245     for ac_prog in gdiff diff
6246 do
6247   # Extract the first word of "$ac_prog", so it can be a program name with args.
6248 set dummy $ac_prog; ac_word=$2
6249 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6250 $as_echo_n "checking for $ac_word... " >&6; }
6251 if ${ac_cv_path_DIFF+:} false; then :
6252   $as_echo_n "(cached) " >&6
6253 else
6254   case $DIFF in
6255   [\\/]* | ?:[\\/]*)
6256   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6257   ;;
6258   *)
6259   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6260 for as_dir in $PATH
6261 do
6262   IFS=$as_save_IFS
6263   test -z "$as_dir" && as_dir=.
6264     for ac_exec_ext in '' $ac_executable_extensions; do
6265   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6266     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6267     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6268     break 2
6269   fi
6270 done
6271   done
6272 IFS=$as_save_IFS
6273 
6274   ;;
6275 esac
6276 fi
6277 DIFF=$ac_cv_path_DIFF
6278 if test -n "$DIFF"; then
6279   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6280 $as_echo "$DIFF" >&6; }
6281 else
6282   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6283 $as_echo "no" >&6; }
6284 fi
6285 
6286 
6287   test -n "$DIFF" && break
6288 done
6289 
6290   else
6291     # The variable is set, but is it from the command line or the environment?
6292 
6293     # Try to remove the string !DIFF! from our list.
6294     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
6295     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6296       # If it failed, the variable was not from the command line. Ignore it,
6297       # but warn the user (except for BASH, which is always set by the calling BASH).
6298       if test "xDIFF" != xBASH; then
6299         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
6300 $as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
6301       fi
6302       # Try to locate tool using the code snippet
6303       for ac_prog in gdiff diff
6304 do
6305   # Extract the first word of "$ac_prog", so it can be a program name with args.
6306 set dummy $ac_prog; ac_word=$2
6307 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6308 $as_echo_n "checking for $ac_word... " >&6; }
6309 if ${ac_cv_path_DIFF+:} false; then :
6310   $as_echo_n "(cached) " >&6
6311 else
6312   case $DIFF in
6313   [\\/]* | ?:[\\/]*)
6314   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6315   ;;
6316   *)
6317   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6318 for as_dir in $PATH
6319 do
6320   IFS=$as_save_IFS
6321   test -z "$as_dir" && as_dir=.
6322     for ac_exec_ext in '' $ac_executable_extensions; do
6323   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6324     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6325     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6326     break 2
6327   fi
6328 done
6329   done
6330 IFS=$as_save_IFS
6331 
6332   ;;
6333 esac
6334 fi
6335 DIFF=$ac_cv_path_DIFF
6336 if test -n "$DIFF"; then
6337   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6338 $as_echo "$DIFF" >&6; }
6339 else
6340   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6341 $as_echo "no" >&6; }
6342 fi
6343 
6344 
6345   test -n "$DIFF" && break
6346 done
6347 
6348     else
6349       # If it succeeded, then it was overridden by the user. We will use it
6350       # for the tool.
6351 
6352       # First remove it from the list of overridden variables, so we can test
6353       # for unknown variables in the end.
6354       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6355 
6356       # Check if the provided tool contains a complete path.
6357       tool_specified="$DIFF"
6358       tool_basename="${tool_specified##*/}"
6359       if test "x$tool_basename" = "x$tool_specified"; then
6360         # A command without a complete path is provided, search $PATH.
6361         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
6362 $as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
6363         # Extract the first word of "$tool_basename", so it can be a program name with args.
6364 set dummy $tool_basename; ac_word=$2
6365 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6366 $as_echo_n "checking for $ac_word... " >&6; }
6367 if ${ac_cv_path_DIFF+:} false; then :
6368   $as_echo_n "(cached) " >&6
6369 else
6370   case $DIFF in
6371   [\\/]* | ?:[\\/]*)
6372   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6373   ;;
6374   *)
6375   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6376 for as_dir in $PATH
6377 do
6378   IFS=$as_save_IFS
6379   test -z "$as_dir" && as_dir=.
6380     for ac_exec_ext in '' $ac_executable_extensions; do
6381   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6382     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6383     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6384     break 2
6385   fi
6386 done
6387   done
6388 IFS=$as_save_IFS
6389 
6390   ;;
6391 esac
6392 fi
6393 DIFF=$ac_cv_path_DIFF
6394 if test -n "$DIFF"; then
6395   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6396 $as_echo "$DIFF" >&6; }
6397 else
6398   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6399 $as_echo "no" >&6; }
6400 fi
6401 
6402 
6403         if test "x$DIFF" = x; then
6404           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6405         fi
6406       else
6407         # Otherwise we believe it is a complete path. Use it as it is.
6408         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
6409 $as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
6410         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
6411 $as_echo_n "checking for DIFF... " >&6; }
6412         if test ! -x "$tool_specified"; then
6413           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6414 $as_echo "not found" >&6; }
6415           as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
6416         fi
6417         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6418 $as_echo "$tool_specified" >&6; }
6419       fi
6420     fi
6421   fi
6422 
6423 
6424 
6425   if test "x$DIFF" = x; then
6426     as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
6427   fi
6428 
6429 
6430 
6431 
6432 
6433   # Publish this variable in the help.
6434 
6435 
6436   if test "x$DIRNAME" = x; then
6437     # The variable is not set by user, try to locate tool using the code snippet
6438     for ac_prog in dirname
6439 do
6440   # Extract the first word of "$ac_prog", so it can be a program name with args.
6441 set dummy $ac_prog; ac_word=$2
6442 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6443 $as_echo_n "checking for $ac_word... " >&6; }
6444 if ${ac_cv_path_DIRNAME+:} false; then :
6445   $as_echo_n "(cached) " >&6
6446 else
6447   case $DIRNAME in
6448   [\\/]* | ?:[\\/]*)
6449   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6450   ;;
6451   *)
6452   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6453 for as_dir in $PATH
6454 do
6455   IFS=$as_save_IFS
6456   test -z "$as_dir" && as_dir=.
6457     for ac_exec_ext in '' $ac_executable_extensions; do
6458   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6459     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6460     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6461     break 2
6462   fi
6463 done
6464   done
6465 IFS=$as_save_IFS
6466 
6467   ;;
6468 esac
6469 fi
6470 DIRNAME=$ac_cv_path_DIRNAME
6471 if test -n "$DIRNAME"; then
6472   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6473 $as_echo "$DIRNAME" >&6; }
6474 else
6475   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6476 $as_echo "no" >&6; }
6477 fi
6478 
6479 
6480   test -n "$DIRNAME" && break
6481 done
6482 
6483   else
6484     # The variable is set, but is it from the command line or the environment?
6485 
6486     # Try to remove the string !DIRNAME! from our list.
6487     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
6488     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6489       # If it failed, the variable was not from the command line. Ignore it,
6490       # but warn the user (except for BASH, which is always set by the calling BASH).
6491       if test "xDIRNAME" != xBASH; then
6492         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
6493 $as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
6494       fi
6495       # Try to locate tool using the code snippet
6496       for ac_prog in dirname
6497 do
6498   # Extract the first word of "$ac_prog", so it can be a program name with args.
6499 set dummy $ac_prog; ac_word=$2
6500 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6501 $as_echo_n "checking for $ac_word... " >&6; }
6502 if ${ac_cv_path_DIRNAME+:} false; then :
6503   $as_echo_n "(cached) " >&6
6504 else
6505   case $DIRNAME in
6506   [\\/]* | ?:[\\/]*)
6507   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6508   ;;
6509   *)
6510   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6511 for as_dir in $PATH
6512 do
6513   IFS=$as_save_IFS
6514   test -z "$as_dir" && as_dir=.
6515     for ac_exec_ext in '' $ac_executable_extensions; do
6516   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6517     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6518     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6519     break 2
6520   fi
6521 done
6522   done
6523 IFS=$as_save_IFS
6524 
6525   ;;
6526 esac
6527 fi
6528 DIRNAME=$ac_cv_path_DIRNAME
6529 if test -n "$DIRNAME"; then
6530   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6531 $as_echo "$DIRNAME" >&6; }
6532 else
6533   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6534 $as_echo "no" >&6; }
6535 fi
6536 
6537 
6538   test -n "$DIRNAME" && break
6539 done
6540 
6541     else
6542       # If it succeeded, then it was overridden by the user. We will use it
6543       # for the tool.
6544 
6545       # First remove it from the list of overridden variables, so we can test
6546       # for unknown variables in the end.
6547       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6548 
6549       # Check if the provided tool contains a complete path.
6550       tool_specified="$DIRNAME"
6551       tool_basename="${tool_specified##*/}"
6552       if test "x$tool_basename" = "x$tool_specified"; then
6553         # A command without a complete path is provided, search $PATH.
6554         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
6555 $as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
6556         # Extract the first word of "$tool_basename", so it can be a program name with args.
6557 set dummy $tool_basename; ac_word=$2
6558 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6559 $as_echo_n "checking for $ac_word... " >&6; }
6560 if ${ac_cv_path_DIRNAME+:} false; then :
6561   $as_echo_n "(cached) " >&6
6562 else
6563   case $DIRNAME in
6564   [\\/]* | ?:[\\/]*)
6565   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6566   ;;
6567   *)
6568   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6569 for as_dir in $PATH
6570 do
6571   IFS=$as_save_IFS
6572   test -z "$as_dir" && as_dir=.
6573     for ac_exec_ext in '' $ac_executable_extensions; do
6574   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6575     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6576     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6577     break 2
6578   fi
6579 done
6580   done
6581 IFS=$as_save_IFS
6582 
6583   ;;
6584 esac
6585 fi
6586 DIRNAME=$ac_cv_path_DIRNAME
6587 if test -n "$DIRNAME"; then
6588   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6589 $as_echo "$DIRNAME" >&6; }
6590 else
6591   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6592 $as_echo "no" >&6; }
6593 fi
6594 
6595 
6596         if test "x$DIRNAME" = x; then
6597           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6598         fi
6599       else
6600         # Otherwise we believe it is a complete path. Use it as it is.
6601         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
6602 $as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
6603         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
6604 $as_echo_n "checking for DIRNAME... " >&6; }
6605         if test ! -x "$tool_specified"; then
6606           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6607 $as_echo "not found" >&6; }
6608           as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
6609         fi
6610         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6611 $as_echo "$tool_specified" >&6; }
6612       fi
6613     fi
6614   fi
6615 
6616 
6617 
6618   if test "x$DIRNAME" = x; then
6619     as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
6620   fi
6621 
6622 
6623 
6624 
6625 
6626   # Publish this variable in the help.
6627 
6628 
6629   if test "x$ECHO" = x; then
6630     # The variable is not set by user, try to locate tool using the code snippet
6631     for ac_prog in echo
6632 do
6633   # Extract the first word of "$ac_prog", so it can be a program name with args.
6634 set dummy $ac_prog; ac_word=$2
6635 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6636 $as_echo_n "checking for $ac_word... " >&6; }
6637 if ${ac_cv_path_ECHO+:} false; then :
6638   $as_echo_n "(cached) " >&6
6639 else
6640   case $ECHO in
6641   [\\/]* | ?:[\\/]*)
6642   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6643   ;;
6644   *)
6645   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6646 for as_dir in $PATH
6647 do
6648   IFS=$as_save_IFS
6649   test -z "$as_dir" && as_dir=.
6650     for ac_exec_ext in '' $ac_executable_extensions; do
6651   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6652     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6653     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6654     break 2
6655   fi
6656 done
6657   done
6658 IFS=$as_save_IFS
6659 
6660   ;;
6661 esac
6662 fi
6663 ECHO=$ac_cv_path_ECHO
6664 if test -n "$ECHO"; then
6665   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6666 $as_echo "$ECHO" >&6; }
6667 else
6668   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6669 $as_echo "no" >&6; }
6670 fi
6671 
6672 
6673   test -n "$ECHO" && break
6674 done
6675 
6676   else
6677     # The variable is set, but is it from the command line or the environment?
6678 
6679     # Try to remove the string !ECHO! from our list.
6680     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
6681     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6682       # If it failed, the variable was not from the command line. Ignore it,
6683       # but warn the user (except for BASH, which is always set by the calling BASH).
6684       if test "xECHO" != xBASH; then
6685         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
6686 $as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
6687       fi
6688       # Try to locate tool using the code snippet
6689       for ac_prog in echo
6690 do
6691   # Extract the first word of "$ac_prog", so it can be a program name with args.
6692 set dummy $ac_prog; ac_word=$2
6693 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6694 $as_echo_n "checking for $ac_word... " >&6; }
6695 if ${ac_cv_path_ECHO+:} false; then :
6696   $as_echo_n "(cached) " >&6
6697 else
6698   case $ECHO in
6699   [\\/]* | ?:[\\/]*)
6700   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6701   ;;
6702   *)
6703   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6704 for as_dir in $PATH
6705 do
6706   IFS=$as_save_IFS
6707   test -z "$as_dir" && as_dir=.
6708     for ac_exec_ext in '' $ac_executable_extensions; do
6709   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6710     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6711     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6712     break 2
6713   fi
6714 done
6715   done
6716 IFS=$as_save_IFS
6717 
6718   ;;
6719 esac
6720 fi
6721 ECHO=$ac_cv_path_ECHO
6722 if test -n "$ECHO"; then
6723   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6724 $as_echo "$ECHO" >&6; }
6725 else
6726   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6727 $as_echo "no" >&6; }
6728 fi
6729 
6730 
6731   test -n "$ECHO" && break
6732 done
6733 
6734     else
6735       # If it succeeded, then it was overridden by the user. We will use it
6736       # for the tool.
6737 
6738       # First remove it from the list of overridden variables, so we can test
6739       # for unknown variables in the end.
6740       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6741 
6742       # Check if the provided tool contains a complete path.
6743       tool_specified="$ECHO"
6744       tool_basename="${tool_specified##*/}"
6745       if test "x$tool_basename" = "x$tool_specified"; then
6746         # A command without a complete path is provided, search $PATH.
6747         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
6748 $as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
6749         # Extract the first word of "$tool_basename", so it can be a program name with args.
6750 set dummy $tool_basename; ac_word=$2
6751 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6752 $as_echo_n "checking for $ac_word... " >&6; }
6753 if ${ac_cv_path_ECHO+:} false; then :
6754   $as_echo_n "(cached) " >&6
6755 else
6756   case $ECHO in
6757   [\\/]* | ?:[\\/]*)
6758   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6759   ;;
6760   *)
6761   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6762 for as_dir in $PATH
6763 do
6764   IFS=$as_save_IFS
6765   test -z "$as_dir" && as_dir=.
6766     for ac_exec_ext in '' $ac_executable_extensions; do
6767   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6768     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6769     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6770     break 2
6771   fi
6772 done
6773   done
6774 IFS=$as_save_IFS
6775 
6776   ;;
6777 esac
6778 fi
6779 ECHO=$ac_cv_path_ECHO
6780 if test -n "$ECHO"; then
6781   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6782 $as_echo "$ECHO" >&6; }
6783 else
6784   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6785 $as_echo "no" >&6; }
6786 fi
6787 
6788 
6789         if test "x$ECHO" = x; then
6790           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6791         fi
6792       else
6793         # Otherwise we believe it is a complete path. Use it as it is.
6794         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
6795 $as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
6796         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
6797 $as_echo_n "checking for ECHO... " >&6; }
6798         if test ! -x "$tool_specified"; then
6799           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6800 $as_echo "not found" >&6; }
6801           as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
6802         fi
6803         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6804 $as_echo "$tool_specified" >&6; }
6805       fi
6806     fi
6807   fi
6808 
6809 
6810 
6811   if test "x$ECHO" = x; then
6812     as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
6813   fi
6814 
6815 
6816 
6817 
6818 
6819   # Publish this variable in the help.
6820 
6821 
6822   if test "x$EXPR" = x; then
6823     # The variable is not set by user, try to locate tool using the code snippet
6824     for ac_prog in expr
6825 do
6826   # Extract the first word of "$ac_prog", so it can be a program name with args.
6827 set dummy $ac_prog; ac_word=$2
6828 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6829 $as_echo_n "checking for $ac_word... " >&6; }
6830 if ${ac_cv_path_EXPR+:} false; then :
6831   $as_echo_n "(cached) " >&6
6832 else
6833   case $EXPR in
6834   [\\/]* | ?:[\\/]*)
6835   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6836   ;;
6837   *)
6838   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6839 for as_dir in $PATH
6840 do
6841   IFS=$as_save_IFS
6842   test -z "$as_dir" && as_dir=.
6843     for ac_exec_ext in '' $ac_executable_extensions; do
6844   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6845     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6846     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6847     break 2
6848   fi
6849 done
6850   done
6851 IFS=$as_save_IFS
6852 
6853   ;;
6854 esac
6855 fi
6856 EXPR=$ac_cv_path_EXPR
6857 if test -n "$EXPR"; then
6858   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6859 $as_echo "$EXPR" >&6; }
6860 else
6861   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6862 $as_echo "no" >&6; }
6863 fi
6864 
6865 
6866   test -n "$EXPR" && break
6867 done
6868 
6869   else
6870     # The variable is set, but is it from the command line or the environment?
6871 
6872     # Try to remove the string !EXPR! from our list.
6873     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
6874     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6875       # If it failed, the variable was not from the command line. Ignore it,
6876       # but warn the user (except for BASH, which is always set by the calling BASH).
6877       if test "xEXPR" != xBASH; then
6878         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
6879 $as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
6880       fi
6881       # Try to locate tool using the code snippet
6882       for ac_prog in expr
6883 do
6884   # Extract the first word of "$ac_prog", so it can be a program name with args.
6885 set dummy $ac_prog; ac_word=$2
6886 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6887 $as_echo_n "checking for $ac_word... " >&6; }
6888 if ${ac_cv_path_EXPR+:} false; then :
6889   $as_echo_n "(cached) " >&6
6890 else
6891   case $EXPR in
6892   [\\/]* | ?:[\\/]*)
6893   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6894   ;;
6895   *)
6896   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6897 for as_dir in $PATH
6898 do
6899   IFS=$as_save_IFS
6900   test -z "$as_dir" && as_dir=.
6901     for ac_exec_ext in '' $ac_executable_extensions; do
6902   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6903     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6904     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6905     break 2
6906   fi
6907 done
6908   done
6909 IFS=$as_save_IFS
6910 
6911   ;;
6912 esac
6913 fi
6914 EXPR=$ac_cv_path_EXPR
6915 if test -n "$EXPR"; then
6916   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6917 $as_echo "$EXPR" >&6; }
6918 else
6919   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6920 $as_echo "no" >&6; }
6921 fi
6922 
6923 
6924   test -n "$EXPR" && break
6925 done
6926 
6927     else
6928       # If it succeeded, then it was overridden by the user. We will use it
6929       # for the tool.
6930 
6931       # First remove it from the list of overridden variables, so we can test
6932       # for unknown variables in the end.
6933       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6934 
6935       # Check if the provided tool contains a complete path.
6936       tool_specified="$EXPR"
6937       tool_basename="${tool_specified##*/}"
6938       if test "x$tool_basename" = "x$tool_specified"; then
6939         # A command without a complete path is provided, search $PATH.
6940         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
6941 $as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
6942         # Extract the first word of "$tool_basename", so it can be a program name with args.
6943 set dummy $tool_basename; ac_word=$2
6944 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6945 $as_echo_n "checking for $ac_word... " >&6; }
6946 if ${ac_cv_path_EXPR+:} false; then :
6947   $as_echo_n "(cached) " >&6
6948 else
6949   case $EXPR in
6950   [\\/]* | ?:[\\/]*)
6951   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6952   ;;
6953   *)
6954   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6955 for as_dir in $PATH
6956 do
6957   IFS=$as_save_IFS
6958   test -z "$as_dir" && as_dir=.
6959     for ac_exec_ext in '' $ac_executable_extensions; do
6960   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6961     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6962     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6963     break 2
6964   fi
6965 done
6966   done
6967 IFS=$as_save_IFS
6968 
6969   ;;
6970 esac
6971 fi
6972 EXPR=$ac_cv_path_EXPR
6973 if test -n "$EXPR"; then
6974   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6975 $as_echo "$EXPR" >&6; }
6976 else
6977   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6978 $as_echo "no" >&6; }
6979 fi
6980 
6981 
6982         if test "x$EXPR" = x; then
6983           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6984         fi
6985       else
6986         # Otherwise we believe it is a complete path. Use it as it is.
6987         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
6988 $as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
6989         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
6990 $as_echo_n "checking for EXPR... " >&6; }
6991         if test ! -x "$tool_specified"; then
6992           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6993 $as_echo "not found" >&6; }
6994           as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
6995         fi
6996         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6997 $as_echo "$tool_specified" >&6; }
6998       fi
6999     fi
7000   fi
7001 
7002 
7003 
7004   if test "x$EXPR" = x; then
7005     as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
7006   fi
7007 
7008 
7009 
7010 
7011 
7012   # Publish this variable in the help.
7013 
7014 
7015   if test "x$FILE" = x; then
7016     # The variable is not set by user, try to locate tool using the code snippet
7017     for ac_prog in file
7018 do
7019   # Extract the first word of "$ac_prog", so it can be a program name with args.
7020 set dummy $ac_prog; ac_word=$2
7021 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7022 $as_echo_n "checking for $ac_word... " >&6; }
7023 if ${ac_cv_path_FILE+:} false; then :
7024   $as_echo_n "(cached) " >&6
7025 else
7026   case $FILE in
7027   [\\/]* | ?:[\\/]*)
7028   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7029   ;;
7030   *)
7031   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7032 for as_dir in $PATH
7033 do
7034   IFS=$as_save_IFS
7035   test -z "$as_dir" && as_dir=.
7036     for ac_exec_ext in '' $ac_executable_extensions; do
7037   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7038     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7039     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7040     break 2
7041   fi
7042 done
7043   done
7044 IFS=$as_save_IFS
7045 
7046   ;;
7047 esac
7048 fi
7049 FILE=$ac_cv_path_FILE
7050 if test -n "$FILE"; then
7051   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7052 $as_echo "$FILE" >&6; }
7053 else
7054   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7055 $as_echo "no" >&6; }
7056 fi
7057 
7058 
7059   test -n "$FILE" && break
7060 done
7061 
7062   else
7063     # The variable is set, but is it from the command line or the environment?
7064 
7065     # Try to remove the string !FILE! from our list.
7066     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
7067     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7068       # If it failed, the variable was not from the command line. Ignore it,
7069       # but warn the user (except for BASH, which is always set by the calling BASH).
7070       if test "xFILE" != xBASH; then
7071         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
7072 $as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
7073       fi
7074       # Try to locate tool using the code snippet
7075       for ac_prog in file
7076 do
7077   # Extract the first word of "$ac_prog", so it can be a program name with args.
7078 set dummy $ac_prog; ac_word=$2
7079 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7080 $as_echo_n "checking for $ac_word... " >&6; }
7081 if ${ac_cv_path_FILE+:} false; then :
7082   $as_echo_n "(cached) " >&6
7083 else
7084   case $FILE in
7085   [\\/]* | ?:[\\/]*)
7086   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7087   ;;
7088   *)
7089   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7090 for as_dir in $PATH
7091 do
7092   IFS=$as_save_IFS
7093   test -z "$as_dir" && as_dir=.
7094     for ac_exec_ext in '' $ac_executable_extensions; do
7095   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7096     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7097     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7098     break 2
7099   fi
7100 done
7101   done
7102 IFS=$as_save_IFS
7103 
7104   ;;
7105 esac
7106 fi
7107 FILE=$ac_cv_path_FILE
7108 if test -n "$FILE"; then
7109   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7110 $as_echo "$FILE" >&6; }
7111 else
7112   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7113 $as_echo "no" >&6; }
7114 fi
7115 
7116 
7117   test -n "$FILE" && break
7118 done
7119 
7120     else
7121       # If it succeeded, then it was overridden by the user. We will use it
7122       # for the tool.
7123 
7124       # First remove it from the list of overridden variables, so we can test
7125       # for unknown variables in the end.
7126       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7127 
7128       # Check if the provided tool contains a complete path.
7129       tool_specified="$FILE"
7130       tool_basename="${tool_specified##*/}"
7131       if test "x$tool_basename" = "x$tool_specified"; then
7132         # A command without a complete path is provided, search $PATH.
7133         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
7134 $as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
7135         # Extract the first word of "$tool_basename", so it can be a program name with args.
7136 set dummy $tool_basename; ac_word=$2
7137 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7138 $as_echo_n "checking for $ac_word... " >&6; }
7139 if ${ac_cv_path_FILE+:} false; then :
7140   $as_echo_n "(cached) " >&6
7141 else
7142   case $FILE in
7143   [\\/]* | ?:[\\/]*)
7144   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7145   ;;
7146   *)
7147   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7148 for as_dir in $PATH
7149 do
7150   IFS=$as_save_IFS
7151   test -z "$as_dir" && as_dir=.
7152     for ac_exec_ext in '' $ac_executable_extensions; do
7153   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7154     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7155     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7156     break 2
7157   fi
7158 done
7159   done
7160 IFS=$as_save_IFS
7161 
7162   ;;
7163 esac
7164 fi
7165 FILE=$ac_cv_path_FILE
7166 if test -n "$FILE"; then
7167   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7168 $as_echo "$FILE" >&6; }
7169 else
7170   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7171 $as_echo "no" >&6; }
7172 fi
7173 
7174 
7175         if test "x$FILE" = x; then
7176           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7177         fi
7178       else
7179         # Otherwise we believe it is a complete path. Use it as it is.
7180         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
7181 $as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
7182         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7183 $as_echo_n "checking for FILE... " >&6; }
7184         if test ! -x "$tool_specified"; then
7185           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7186 $as_echo "not found" >&6; }
7187           as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
7188         fi
7189         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7190 $as_echo "$tool_specified" >&6; }
7191       fi
7192     fi
7193   fi
7194 
7195 
7196 
7197   if test "x$FILE" = x; then
7198     as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
7199   fi
7200 
7201 
7202 
7203 
7204 
7205   # Publish this variable in the help.
7206 
7207 
7208   if test "x$FIND" = x; then
7209     # The variable is not set by user, try to locate tool using the code snippet
7210     for ac_prog in find
7211 do
7212   # Extract the first word of "$ac_prog", so it can be a program name with args.
7213 set dummy $ac_prog; ac_word=$2
7214 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7215 $as_echo_n "checking for $ac_word... " >&6; }
7216 if ${ac_cv_path_FIND+:} false; then :
7217   $as_echo_n "(cached) " >&6
7218 else
7219   case $FIND in
7220   [\\/]* | ?:[\\/]*)
7221   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7222   ;;
7223   *)
7224   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7225 for as_dir in $PATH
7226 do
7227   IFS=$as_save_IFS
7228   test -z "$as_dir" && as_dir=.
7229     for ac_exec_ext in '' $ac_executable_extensions; do
7230   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7231     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7232     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7233     break 2
7234   fi
7235 done
7236   done
7237 IFS=$as_save_IFS
7238 
7239   ;;
7240 esac
7241 fi
7242 FIND=$ac_cv_path_FIND
7243 if test -n "$FIND"; then
7244   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7245 $as_echo "$FIND" >&6; }
7246 else
7247   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7248 $as_echo "no" >&6; }
7249 fi
7250 
7251 
7252   test -n "$FIND" && break
7253 done
7254 
7255   else
7256     # The variable is set, but is it from the command line or the environment?
7257 
7258     # Try to remove the string !FIND! from our list.
7259     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
7260     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7261       # If it failed, the variable was not from the command line. Ignore it,
7262       # but warn the user (except for BASH, which is always set by the calling BASH).
7263       if test "xFIND" != xBASH; then
7264         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
7265 $as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
7266       fi
7267       # Try to locate tool using the code snippet
7268       for ac_prog in find
7269 do
7270   # Extract the first word of "$ac_prog", so it can be a program name with args.
7271 set dummy $ac_prog; ac_word=$2
7272 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7273 $as_echo_n "checking for $ac_word... " >&6; }
7274 if ${ac_cv_path_FIND+:} false; then :
7275   $as_echo_n "(cached) " >&6
7276 else
7277   case $FIND in
7278   [\\/]* | ?:[\\/]*)
7279   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7280   ;;
7281   *)
7282   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7283 for as_dir in $PATH
7284 do
7285   IFS=$as_save_IFS
7286   test -z "$as_dir" && as_dir=.
7287     for ac_exec_ext in '' $ac_executable_extensions; do
7288   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7289     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7290     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7291     break 2
7292   fi
7293 done
7294   done
7295 IFS=$as_save_IFS
7296 
7297   ;;
7298 esac
7299 fi
7300 FIND=$ac_cv_path_FIND
7301 if test -n "$FIND"; then
7302   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7303 $as_echo "$FIND" >&6; }
7304 else
7305   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7306 $as_echo "no" >&6; }
7307 fi
7308 
7309 
7310   test -n "$FIND" && break
7311 done
7312 
7313     else
7314       # If it succeeded, then it was overridden by the user. We will use it
7315       # for the tool.
7316 
7317       # First remove it from the list of overridden variables, so we can test
7318       # for unknown variables in the end.
7319       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7320 
7321       # Check if the provided tool contains a complete path.
7322       tool_specified="$FIND"
7323       tool_basename="${tool_specified##*/}"
7324       if test "x$tool_basename" = "x$tool_specified"; then
7325         # A command without a complete path is provided, search $PATH.
7326         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
7327 $as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
7328         # Extract the first word of "$tool_basename", so it can be a program name with args.
7329 set dummy $tool_basename; ac_word=$2
7330 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7331 $as_echo_n "checking for $ac_word... " >&6; }
7332 if ${ac_cv_path_FIND+:} false; then :
7333   $as_echo_n "(cached) " >&6
7334 else
7335   case $FIND in
7336   [\\/]* | ?:[\\/]*)
7337   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7338   ;;
7339   *)
7340   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7341 for as_dir in $PATH
7342 do
7343   IFS=$as_save_IFS
7344   test -z "$as_dir" && as_dir=.
7345     for ac_exec_ext in '' $ac_executable_extensions; do
7346   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7347     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7348     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7349     break 2
7350   fi
7351 done
7352   done
7353 IFS=$as_save_IFS
7354 
7355   ;;
7356 esac
7357 fi
7358 FIND=$ac_cv_path_FIND
7359 if test -n "$FIND"; then
7360   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7361 $as_echo "$FIND" >&6; }
7362 else
7363   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7364 $as_echo "no" >&6; }
7365 fi
7366 
7367 
7368         if test "x$FIND" = x; then
7369           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7370         fi
7371       else
7372         # Otherwise we believe it is a complete path. Use it as it is.
7373         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
7374 $as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
7375         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
7376 $as_echo_n "checking for FIND... " >&6; }
7377         if test ! -x "$tool_specified"; then
7378           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7379 $as_echo "not found" >&6; }
7380           as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
7381         fi
7382         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7383 $as_echo "$tool_specified" >&6; }
7384       fi
7385     fi
7386   fi
7387 
7388 
7389 
7390   if test "x$FIND" = x; then
7391     as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
7392   fi
7393 
7394 
7395 
7396 
7397 
7398   # Publish this variable in the help.
7399 
7400 
7401   if test "x$HEAD" = x; then
7402     # The variable is not set by user, try to locate tool using the code snippet
7403     for ac_prog in head
7404 do
7405   # Extract the first word of "$ac_prog", so it can be a program name with args.
7406 set dummy $ac_prog; ac_word=$2
7407 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7408 $as_echo_n "checking for $ac_word... " >&6; }
7409 if ${ac_cv_path_HEAD+:} false; then :
7410   $as_echo_n "(cached) " >&6
7411 else
7412   case $HEAD in
7413   [\\/]* | ?:[\\/]*)
7414   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7415   ;;
7416   *)
7417   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7418 for as_dir in $PATH
7419 do
7420   IFS=$as_save_IFS
7421   test -z "$as_dir" && as_dir=.
7422     for ac_exec_ext in '' $ac_executable_extensions; do
7423   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7424     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7425     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7426     break 2
7427   fi
7428 done
7429   done
7430 IFS=$as_save_IFS
7431 
7432   ;;
7433 esac
7434 fi
7435 HEAD=$ac_cv_path_HEAD
7436 if test -n "$HEAD"; then
7437   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7438 $as_echo "$HEAD" >&6; }
7439 else
7440   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7441 $as_echo "no" >&6; }
7442 fi
7443 
7444 
7445   test -n "$HEAD" && break
7446 done
7447 
7448   else
7449     # The variable is set, but is it from the command line or the environment?
7450 
7451     # Try to remove the string !HEAD! from our list.
7452     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
7453     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7454       # If it failed, the variable was not from the command line. Ignore it,
7455       # but warn the user (except for BASH, which is always set by the calling BASH).
7456       if test "xHEAD" != xBASH; then
7457         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
7458 $as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
7459       fi
7460       # Try to locate tool using the code snippet
7461       for ac_prog in head
7462 do
7463   # Extract the first word of "$ac_prog", so it can be a program name with args.
7464 set dummy $ac_prog; ac_word=$2
7465 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7466 $as_echo_n "checking for $ac_word... " >&6; }
7467 if ${ac_cv_path_HEAD+:} false; then :
7468   $as_echo_n "(cached) " >&6
7469 else
7470   case $HEAD in
7471   [\\/]* | ?:[\\/]*)
7472   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7473   ;;
7474   *)
7475   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7476 for as_dir in $PATH
7477 do
7478   IFS=$as_save_IFS
7479   test -z "$as_dir" && as_dir=.
7480     for ac_exec_ext in '' $ac_executable_extensions; do
7481   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7482     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7483     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7484     break 2
7485   fi
7486 done
7487   done
7488 IFS=$as_save_IFS
7489 
7490   ;;
7491 esac
7492 fi
7493 HEAD=$ac_cv_path_HEAD
7494 if test -n "$HEAD"; then
7495   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7496 $as_echo "$HEAD" >&6; }
7497 else
7498   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7499 $as_echo "no" >&6; }
7500 fi
7501 
7502 
7503   test -n "$HEAD" && break
7504 done
7505 
7506     else
7507       # If it succeeded, then it was overridden by the user. We will use it
7508       # for the tool.
7509 
7510       # First remove it from the list of overridden variables, so we can test
7511       # for unknown variables in the end.
7512       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7513 
7514       # Check if the provided tool contains a complete path.
7515       tool_specified="$HEAD"
7516       tool_basename="${tool_specified##*/}"
7517       if test "x$tool_basename" = "x$tool_specified"; then
7518         # A command without a complete path is provided, search $PATH.
7519         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
7520 $as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
7521         # Extract the first word of "$tool_basename", so it can be a program name with args.
7522 set dummy $tool_basename; ac_word=$2
7523 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7524 $as_echo_n "checking for $ac_word... " >&6; }
7525 if ${ac_cv_path_HEAD+:} false; then :
7526   $as_echo_n "(cached) " >&6
7527 else
7528   case $HEAD in
7529   [\\/]* | ?:[\\/]*)
7530   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7531   ;;
7532   *)
7533   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7534 for as_dir in $PATH
7535 do
7536   IFS=$as_save_IFS
7537   test -z "$as_dir" && as_dir=.
7538     for ac_exec_ext in '' $ac_executable_extensions; do
7539   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7540     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7541     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7542     break 2
7543   fi
7544 done
7545   done
7546 IFS=$as_save_IFS
7547 
7548   ;;
7549 esac
7550 fi
7551 HEAD=$ac_cv_path_HEAD
7552 if test -n "$HEAD"; then
7553   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7554 $as_echo "$HEAD" >&6; }
7555 else
7556   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7557 $as_echo "no" >&6; }
7558 fi
7559 
7560 
7561         if test "x$HEAD" = x; then
7562           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7563         fi
7564       else
7565         # Otherwise we believe it is a complete path. Use it as it is.
7566         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
7567 $as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
7568         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
7569 $as_echo_n "checking for HEAD... " >&6; }
7570         if test ! -x "$tool_specified"; then
7571           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7572 $as_echo "not found" >&6; }
7573           as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
7574         fi
7575         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7576 $as_echo "$tool_specified" >&6; }
7577       fi
7578     fi
7579   fi
7580 
7581 
7582 
7583   if test "x$HEAD" = x; then
7584     as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
7585   fi
7586 
7587 
7588 
7589 
7590 
7591   # Publish this variable in the help.
7592 
7593 
7594   if test "x$LN" = x; then
7595     # The variable is not set by user, try to locate tool using the code snippet
7596     for ac_prog in ln
7597 do
7598   # Extract the first word of "$ac_prog", so it can be a program name with args.
7599 set dummy $ac_prog; ac_word=$2
7600 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7601 $as_echo_n "checking for $ac_word... " >&6; }
7602 if ${ac_cv_path_LN+:} false; then :
7603   $as_echo_n "(cached) " >&6
7604 else
7605   case $LN in
7606   [\\/]* | ?:[\\/]*)
7607   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7608   ;;
7609   *)
7610   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7611 for as_dir in $PATH
7612 do
7613   IFS=$as_save_IFS
7614   test -z "$as_dir" && as_dir=.
7615     for ac_exec_ext in '' $ac_executable_extensions; do
7616   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7617     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7618     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7619     break 2
7620   fi
7621 done
7622   done
7623 IFS=$as_save_IFS
7624 
7625   ;;
7626 esac
7627 fi
7628 LN=$ac_cv_path_LN
7629 if test -n "$LN"; then
7630   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7631 $as_echo "$LN" >&6; }
7632 else
7633   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7634 $as_echo "no" >&6; }
7635 fi
7636 
7637 
7638   test -n "$LN" && break
7639 done
7640 
7641   else
7642     # The variable is set, but is it from the command line or the environment?
7643 
7644     # Try to remove the string !LN! from our list.
7645     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
7646     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7647       # If it failed, the variable was not from the command line. Ignore it,
7648       # but warn the user (except for BASH, which is always set by the calling BASH).
7649       if test "xLN" != xBASH; then
7650         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
7651 $as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
7652       fi
7653       # Try to locate tool using the code snippet
7654       for ac_prog in ln
7655 do
7656   # Extract the first word of "$ac_prog", so it can be a program name with args.
7657 set dummy $ac_prog; ac_word=$2
7658 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7659 $as_echo_n "checking for $ac_word... " >&6; }
7660 if ${ac_cv_path_LN+:} false; then :
7661   $as_echo_n "(cached) " >&6
7662 else
7663   case $LN in
7664   [\\/]* | ?:[\\/]*)
7665   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7666   ;;
7667   *)
7668   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7669 for as_dir in $PATH
7670 do
7671   IFS=$as_save_IFS
7672   test -z "$as_dir" && as_dir=.
7673     for ac_exec_ext in '' $ac_executable_extensions; do
7674   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7675     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7676     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7677     break 2
7678   fi
7679 done
7680   done
7681 IFS=$as_save_IFS
7682 
7683   ;;
7684 esac
7685 fi
7686 LN=$ac_cv_path_LN
7687 if test -n "$LN"; then
7688   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7689 $as_echo "$LN" >&6; }
7690 else
7691   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7692 $as_echo "no" >&6; }
7693 fi
7694 
7695 
7696   test -n "$LN" && break
7697 done
7698 
7699     else
7700       # If it succeeded, then it was overridden by the user. We will use it
7701       # for the tool.
7702 
7703       # First remove it from the list of overridden variables, so we can test
7704       # for unknown variables in the end.
7705       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7706 
7707       # Check if the provided tool contains a complete path.
7708       tool_specified="$LN"
7709       tool_basename="${tool_specified##*/}"
7710       if test "x$tool_basename" = "x$tool_specified"; then
7711         # A command without a complete path is provided, search $PATH.
7712         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
7713 $as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
7714         # Extract the first word of "$tool_basename", so it can be a program name with args.
7715 set dummy $tool_basename; ac_word=$2
7716 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7717 $as_echo_n "checking for $ac_word... " >&6; }
7718 if ${ac_cv_path_LN+:} false; then :
7719   $as_echo_n "(cached) " >&6
7720 else
7721   case $LN in
7722   [\\/]* | ?:[\\/]*)
7723   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7724   ;;
7725   *)
7726   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7727 for as_dir in $PATH
7728 do
7729   IFS=$as_save_IFS
7730   test -z "$as_dir" && as_dir=.
7731     for ac_exec_ext in '' $ac_executable_extensions; do
7732   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7733     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7734     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7735     break 2
7736   fi
7737 done
7738   done
7739 IFS=$as_save_IFS
7740 
7741   ;;
7742 esac
7743 fi
7744 LN=$ac_cv_path_LN
7745 if test -n "$LN"; then
7746   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7747 $as_echo "$LN" >&6; }
7748 else
7749   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7750 $as_echo "no" >&6; }
7751 fi
7752 
7753 
7754         if test "x$LN" = x; then
7755           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7756         fi
7757       else
7758         # Otherwise we believe it is a complete path. Use it as it is.
7759         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
7760 $as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
7761         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
7762 $as_echo_n "checking for LN... " >&6; }
7763         if test ! -x "$tool_specified"; then
7764           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7765 $as_echo "not found" >&6; }
7766           as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
7767         fi
7768         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7769 $as_echo "$tool_specified" >&6; }
7770       fi
7771     fi
7772   fi
7773 
7774 
7775 
7776   if test "x$LN" = x; then
7777     as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
7778   fi
7779 
7780 
7781 
7782 
7783 
7784   # Publish this variable in the help.
7785 
7786 
7787   if test "x$LS" = x; then
7788     # The variable is not set by user, try to locate tool using the code snippet
7789     for ac_prog in ls
7790 do
7791   # Extract the first word of "$ac_prog", so it can be a program name with args.
7792 set dummy $ac_prog; ac_word=$2
7793 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7794 $as_echo_n "checking for $ac_word... " >&6; }
7795 if ${ac_cv_path_LS+:} false; then :
7796   $as_echo_n "(cached) " >&6
7797 else
7798   case $LS in
7799   [\\/]* | ?:[\\/]*)
7800   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7801   ;;
7802   *)
7803   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7804 for as_dir in $PATH
7805 do
7806   IFS=$as_save_IFS
7807   test -z "$as_dir" && as_dir=.
7808     for ac_exec_ext in '' $ac_executable_extensions; do
7809   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7810     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7811     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7812     break 2
7813   fi
7814 done
7815   done
7816 IFS=$as_save_IFS
7817 
7818   ;;
7819 esac
7820 fi
7821 LS=$ac_cv_path_LS
7822 if test -n "$LS"; then
7823   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7824 $as_echo "$LS" >&6; }
7825 else
7826   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7827 $as_echo "no" >&6; }
7828 fi
7829 
7830 
7831   test -n "$LS" && break
7832 done
7833 
7834   else
7835     # The variable is set, but is it from the command line or the environment?
7836 
7837     # Try to remove the string !LS! from our list.
7838     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
7839     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7840       # If it failed, the variable was not from the command line. Ignore it,
7841       # but warn the user (except for BASH, which is always set by the calling BASH).
7842       if test "xLS" != xBASH; then
7843         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
7844 $as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
7845       fi
7846       # Try to locate tool using the code snippet
7847       for ac_prog in ls
7848 do
7849   # Extract the first word of "$ac_prog", so it can be a program name with args.
7850 set dummy $ac_prog; ac_word=$2
7851 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7852 $as_echo_n "checking for $ac_word... " >&6; }
7853 if ${ac_cv_path_LS+:} false; then :
7854   $as_echo_n "(cached) " >&6
7855 else
7856   case $LS in
7857   [\\/]* | ?:[\\/]*)
7858   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7859   ;;
7860   *)
7861   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7862 for as_dir in $PATH
7863 do
7864   IFS=$as_save_IFS
7865   test -z "$as_dir" && as_dir=.
7866     for ac_exec_ext in '' $ac_executable_extensions; do
7867   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7868     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7869     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7870     break 2
7871   fi
7872 done
7873   done
7874 IFS=$as_save_IFS
7875 
7876   ;;
7877 esac
7878 fi
7879 LS=$ac_cv_path_LS
7880 if test -n "$LS"; then
7881   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7882 $as_echo "$LS" >&6; }
7883 else
7884   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7885 $as_echo "no" >&6; }
7886 fi
7887 
7888 
7889   test -n "$LS" && break
7890 done
7891 
7892     else
7893       # If it succeeded, then it was overridden by the user. We will use it
7894       # for the tool.
7895 
7896       # First remove it from the list of overridden variables, so we can test
7897       # for unknown variables in the end.
7898       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7899 
7900       # Check if the provided tool contains a complete path.
7901       tool_specified="$LS"
7902       tool_basename="${tool_specified##*/}"
7903       if test "x$tool_basename" = "x$tool_specified"; then
7904         # A command without a complete path is provided, search $PATH.
7905         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
7906 $as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
7907         # Extract the first word of "$tool_basename", so it can be a program name with args.
7908 set dummy $tool_basename; ac_word=$2
7909 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7910 $as_echo_n "checking for $ac_word... " >&6; }
7911 if ${ac_cv_path_LS+:} false; then :
7912   $as_echo_n "(cached) " >&6
7913 else
7914   case $LS in
7915   [\\/]* | ?:[\\/]*)
7916   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7917   ;;
7918   *)
7919   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7920 for as_dir in $PATH
7921 do
7922   IFS=$as_save_IFS
7923   test -z "$as_dir" && as_dir=.
7924     for ac_exec_ext in '' $ac_executable_extensions; do
7925   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7926     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7927     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7928     break 2
7929   fi
7930 done
7931   done
7932 IFS=$as_save_IFS
7933 
7934   ;;
7935 esac
7936 fi
7937 LS=$ac_cv_path_LS
7938 if test -n "$LS"; then
7939   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7940 $as_echo "$LS" >&6; }
7941 else
7942   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7943 $as_echo "no" >&6; }
7944 fi
7945 
7946 
7947         if test "x$LS" = x; then
7948           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7949         fi
7950       else
7951         # Otherwise we believe it is a complete path. Use it as it is.
7952         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
7953 $as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
7954         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
7955 $as_echo_n "checking for LS... " >&6; }
7956         if test ! -x "$tool_specified"; then
7957           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7958 $as_echo "not found" >&6; }
7959           as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
7960         fi
7961         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7962 $as_echo "$tool_specified" >&6; }
7963       fi
7964     fi
7965   fi
7966 
7967 
7968 
7969   if test "x$LS" = x; then
7970     as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
7971   fi
7972 
7973 
7974 
7975 
7976 
7977   # Publish this variable in the help.
7978 
7979 
7980   if test "x$MKDIR" = x; then
7981     # The variable is not set by user, try to locate tool using the code snippet
7982     for ac_prog in mkdir
7983 do
7984   # Extract the first word of "$ac_prog", so it can be a program name with args.
7985 set dummy $ac_prog; ac_word=$2
7986 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7987 $as_echo_n "checking for $ac_word... " >&6; }
7988 if ${ac_cv_path_MKDIR+:} false; then :
7989   $as_echo_n "(cached) " >&6
7990 else
7991   case $MKDIR in
7992   [\\/]* | ?:[\\/]*)
7993   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7994   ;;
7995   *)
7996   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7997 for as_dir in $PATH
7998 do
7999   IFS=$as_save_IFS
8000   test -z "$as_dir" && as_dir=.
8001     for ac_exec_ext in '' $ac_executable_extensions; do
8002   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8003     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8004     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8005     break 2
8006   fi
8007 done
8008   done
8009 IFS=$as_save_IFS
8010 
8011   ;;
8012 esac
8013 fi
8014 MKDIR=$ac_cv_path_MKDIR
8015 if test -n "$MKDIR"; then
8016   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8017 $as_echo "$MKDIR" >&6; }
8018 else
8019   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8020 $as_echo "no" >&6; }
8021 fi
8022 
8023 
8024   test -n "$MKDIR" && break
8025 done
8026 
8027   else
8028     # The variable is set, but is it from the command line or the environment?
8029 
8030     # Try to remove the string !MKDIR! from our list.
8031     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
8032     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8033       # If it failed, the variable was not from the command line. Ignore it,
8034       # but warn the user (except for BASH, which is always set by the calling BASH).
8035       if test "xMKDIR" != xBASH; then
8036         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
8037 $as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
8038       fi
8039       # Try to locate tool using the code snippet
8040       for ac_prog in mkdir
8041 do
8042   # Extract the first word of "$ac_prog", so it can be a program name with args.
8043 set dummy $ac_prog; ac_word=$2
8044 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8045 $as_echo_n "checking for $ac_word... " >&6; }
8046 if ${ac_cv_path_MKDIR+:} false; then :
8047   $as_echo_n "(cached) " >&6
8048 else
8049   case $MKDIR in
8050   [\\/]* | ?:[\\/]*)
8051   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8052   ;;
8053   *)
8054   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8055 for as_dir in $PATH
8056 do
8057   IFS=$as_save_IFS
8058   test -z "$as_dir" && as_dir=.
8059     for ac_exec_ext in '' $ac_executable_extensions; do
8060   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8061     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8062     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8063     break 2
8064   fi
8065 done
8066   done
8067 IFS=$as_save_IFS
8068 
8069   ;;
8070 esac
8071 fi
8072 MKDIR=$ac_cv_path_MKDIR
8073 if test -n "$MKDIR"; then
8074   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8075 $as_echo "$MKDIR" >&6; }
8076 else
8077   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8078 $as_echo "no" >&6; }
8079 fi
8080 
8081 
8082   test -n "$MKDIR" && break
8083 done
8084 
8085     else
8086       # If it succeeded, then it was overridden by the user. We will use it
8087       # for the tool.
8088 
8089       # First remove it from the list of overridden variables, so we can test
8090       # for unknown variables in the end.
8091       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8092 
8093       # Check if the provided tool contains a complete path.
8094       tool_specified="$MKDIR"
8095       tool_basename="${tool_specified##*/}"
8096       if test "x$tool_basename" = "x$tool_specified"; then
8097         # A command without a complete path is provided, search $PATH.
8098         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
8099 $as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
8100         # Extract the first word of "$tool_basename", so it can be a program name with args.
8101 set dummy $tool_basename; ac_word=$2
8102 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8103 $as_echo_n "checking for $ac_word... " >&6; }
8104 if ${ac_cv_path_MKDIR+:} false; then :
8105   $as_echo_n "(cached) " >&6
8106 else
8107   case $MKDIR in
8108   [\\/]* | ?:[\\/]*)
8109   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8110   ;;
8111   *)
8112   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8113 for as_dir in $PATH
8114 do
8115   IFS=$as_save_IFS
8116   test -z "$as_dir" && as_dir=.
8117     for ac_exec_ext in '' $ac_executable_extensions; do
8118   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8119     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8120     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8121     break 2
8122   fi
8123 done
8124   done
8125 IFS=$as_save_IFS
8126 
8127   ;;
8128 esac
8129 fi
8130 MKDIR=$ac_cv_path_MKDIR
8131 if test -n "$MKDIR"; then
8132   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8133 $as_echo "$MKDIR" >&6; }
8134 else
8135   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8136 $as_echo "no" >&6; }
8137 fi
8138 
8139 
8140         if test "x$MKDIR" = x; then
8141           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8142         fi
8143       else
8144         # Otherwise we believe it is a complete path. Use it as it is.
8145         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
8146 $as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
8147         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
8148 $as_echo_n "checking for MKDIR... " >&6; }
8149         if test ! -x "$tool_specified"; then
8150           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8151 $as_echo "not found" >&6; }
8152           as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
8153         fi
8154         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8155 $as_echo "$tool_specified" >&6; }
8156       fi
8157     fi
8158   fi
8159 
8160 
8161 
8162   if test "x$MKDIR" = x; then
8163     as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
8164   fi
8165 
8166 
8167 
8168 
8169 
8170   # Publish this variable in the help.
8171 
8172 
8173   if test "x$MKTEMP" = x; then
8174     # The variable is not set by user, try to locate tool using the code snippet
8175     for ac_prog in mktemp
8176 do
8177   # Extract the first word of "$ac_prog", so it can be a program name with args.
8178 set dummy $ac_prog; ac_word=$2
8179 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8180 $as_echo_n "checking for $ac_word... " >&6; }
8181 if ${ac_cv_path_MKTEMP+:} false; then :
8182   $as_echo_n "(cached) " >&6
8183 else
8184   case $MKTEMP in
8185   [\\/]* | ?:[\\/]*)
8186   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8187   ;;
8188   *)
8189   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8190 for as_dir in $PATH
8191 do
8192   IFS=$as_save_IFS
8193   test -z "$as_dir" && as_dir=.
8194     for ac_exec_ext in '' $ac_executable_extensions; do
8195   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8196     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8197     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8198     break 2
8199   fi
8200 done
8201   done
8202 IFS=$as_save_IFS
8203 
8204   ;;
8205 esac
8206 fi
8207 MKTEMP=$ac_cv_path_MKTEMP
8208 if test -n "$MKTEMP"; then
8209   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8210 $as_echo "$MKTEMP" >&6; }
8211 else
8212   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8213 $as_echo "no" >&6; }
8214 fi
8215 
8216 
8217   test -n "$MKTEMP" && break
8218 done
8219 
8220   else
8221     # The variable is set, but is it from the command line or the environment?
8222 
8223     # Try to remove the string !MKTEMP! from our list.
8224     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
8225     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8226       # If it failed, the variable was not from the command line. Ignore it,
8227       # but warn the user (except for BASH, which is always set by the calling BASH).
8228       if test "xMKTEMP" != xBASH; then
8229         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
8230 $as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
8231       fi
8232       # Try to locate tool using the code snippet
8233       for ac_prog in mktemp
8234 do
8235   # Extract the first word of "$ac_prog", so it can be a program name with args.
8236 set dummy $ac_prog; ac_word=$2
8237 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8238 $as_echo_n "checking for $ac_word... " >&6; }
8239 if ${ac_cv_path_MKTEMP+:} false; then :
8240   $as_echo_n "(cached) " >&6
8241 else
8242   case $MKTEMP in
8243   [\\/]* | ?:[\\/]*)
8244   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8245   ;;
8246   *)
8247   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8248 for as_dir in $PATH
8249 do
8250   IFS=$as_save_IFS
8251   test -z "$as_dir" && as_dir=.
8252     for ac_exec_ext in '' $ac_executable_extensions; do
8253   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8254     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8255     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8256     break 2
8257   fi
8258 done
8259   done
8260 IFS=$as_save_IFS
8261 
8262   ;;
8263 esac
8264 fi
8265 MKTEMP=$ac_cv_path_MKTEMP
8266 if test -n "$MKTEMP"; then
8267   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8268 $as_echo "$MKTEMP" >&6; }
8269 else
8270   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8271 $as_echo "no" >&6; }
8272 fi
8273 
8274 
8275   test -n "$MKTEMP" && break
8276 done
8277 
8278     else
8279       # If it succeeded, then it was overridden by the user. We will use it
8280       # for the tool.
8281 
8282       # First remove it from the list of overridden variables, so we can test
8283       # for unknown variables in the end.
8284       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8285 
8286       # Check if the provided tool contains a complete path.
8287       tool_specified="$MKTEMP"
8288       tool_basename="${tool_specified##*/}"
8289       if test "x$tool_basename" = "x$tool_specified"; then
8290         # A command without a complete path is provided, search $PATH.
8291         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
8292 $as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
8293         # Extract the first word of "$tool_basename", so it can be a program name with args.
8294 set dummy $tool_basename; ac_word=$2
8295 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8296 $as_echo_n "checking for $ac_word... " >&6; }
8297 if ${ac_cv_path_MKTEMP+:} false; then :
8298   $as_echo_n "(cached) " >&6
8299 else
8300   case $MKTEMP in
8301   [\\/]* | ?:[\\/]*)
8302   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8303   ;;
8304   *)
8305   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8306 for as_dir in $PATH
8307 do
8308   IFS=$as_save_IFS
8309   test -z "$as_dir" && as_dir=.
8310     for ac_exec_ext in '' $ac_executable_extensions; do
8311   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8312     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8313     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8314     break 2
8315   fi
8316 done
8317   done
8318 IFS=$as_save_IFS
8319 
8320   ;;
8321 esac
8322 fi
8323 MKTEMP=$ac_cv_path_MKTEMP
8324 if test -n "$MKTEMP"; then
8325   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8326 $as_echo "$MKTEMP" >&6; }
8327 else
8328   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8329 $as_echo "no" >&6; }
8330 fi
8331 
8332 
8333         if test "x$MKTEMP" = x; then
8334           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8335         fi
8336       else
8337         # Otherwise we believe it is a complete path. Use it as it is.
8338         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
8339 $as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
8340         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
8341 $as_echo_n "checking for MKTEMP... " >&6; }
8342         if test ! -x "$tool_specified"; then
8343           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8344 $as_echo "not found" >&6; }
8345           as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
8346         fi
8347         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8348 $as_echo "$tool_specified" >&6; }
8349       fi
8350     fi
8351   fi
8352 
8353 
8354 
8355   if test "x$MKTEMP" = x; then
8356     as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
8357   fi
8358 
8359 
8360 
8361 
8362 
8363   # Publish this variable in the help.
8364 
8365 
8366   if test "x$MV" = x; then
8367     # The variable is not set by user, try to locate tool using the code snippet
8368     for ac_prog in mv
8369 do
8370   # Extract the first word of "$ac_prog", so it can be a program name with args.
8371 set dummy $ac_prog; ac_word=$2
8372 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8373 $as_echo_n "checking for $ac_word... " >&6; }
8374 if ${ac_cv_path_MV+:} false; then :
8375   $as_echo_n "(cached) " >&6
8376 else
8377   case $MV in
8378   [\\/]* | ?:[\\/]*)
8379   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8380   ;;
8381   *)
8382   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8383 for as_dir in $PATH
8384 do
8385   IFS=$as_save_IFS
8386   test -z "$as_dir" && as_dir=.
8387     for ac_exec_ext in '' $ac_executable_extensions; do
8388   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8389     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8390     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8391     break 2
8392   fi
8393 done
8394   done
8395 IFS=$as_save_IFS
8396 
8397   ;;
8398 esac
8399 fi
8400 MV=$ac_cv_path_MV
8401 if test -n "$MV"; then
8402   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8403 $as_echo "$MV" >&6; }
8404 else
8405   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8406 $as_echo "no" >&6; }
8407 fi
8408 
8409 
8410   test -n "$MV" && break
8411 done
8412 
8413   else
8414     # The variable is set, but is it from the command line or the environment?
8415 
8416     # Try to remove the string !MV! from our list.
8417     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
8418     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8419       # If it failed, the variable was not from the command line. Ignore it,
8420       # but warn the user (except for BASH, which is always set by the calling BASH).
8421       if test "xMV" != xBASH; then
8422         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
8423 $as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
8424       fi
8425       # Try to locate tool using the code snippet
8426       for ac_prog in mv
8427 do
8428   # Extract the first word of "$ac_prog", so it can be a program name with args.
8429 set dummy $ac_prog; ac_word=$2
8430 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8431 $as_echo_n "checking for $ac_word... " >&6; }
8432 if ${ac_cv_path_MV+:} false; then :
8433   $as_echo_n "(cached) " >&6
8434 else
8435   case $MV in
8436   [\\/]* | ?:[\\/]*)
8437   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8438   ;;
8439   *)
8440   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8441 for as_dir in $PATH
8442 do
8443   IFS=$as_save_IFS
8444   test -z "$as_dir" && as_dir=.
8445     for ac_exec_ext in '' $ac_executable_extensions; do
8446   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8447     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8448     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8449     break 2
8450   fi
8451 done
8452   done
8453 IFS=$as_save_IFS
8454 
8455   ;;
8456 esac
8457 fi
8458 MV=$ac_cv_path_MV
8459 if test -n "$MV"; then
8460   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8461 $as_echo "$MV" >&6; }
8462 else
8463   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8464 $as_echo "no" >&6; }
8465 fi
8466 
8467 
8468   test -n "$MV" && break
8469 done
8470 
8471     else
8472       # If it succeeded, then it was overridden by the user. We will use it
8473       # for the tool.
8474 
8475       # First remove it from the list of overridden variables, so we can test
8476       # for unknown variables in the end.
8477       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8478 
8479       # Check if the provided tool contains a complete path.
8480       tool_specified="$MV"
8481       tool_basename="${tool_specified##*/}"
8482       if test "x$tool_basename" = "x$tool_specified"; then
8483         # A command without a complete path is provided, search $PATH.
8484         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
8485 $as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
8486         # Extract the first word of "$tool_basename", so it can be a program name with args.
8487 set dummy $tool_basename; ac_word=$2
8488 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8489 $as_echo_n "checking for $ac_word... " >&6; }
8490 if ${ac_cv_path_MV+:} false; then :
8491   $as_echo_n "(cached) " >&6
8492 else
8493   case $MV in
8494   [\\/]* | ?:[\\/]*)
8495   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8496   ;;
8497   *)
8498   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8499 for as_dir in $PATH
8500 do
8501   IFS=$as_save_IFS
8502   test -z "$as_dir" && as_dir=.
8503     for ac_exec_ext in '' $ac_executable_extensions; do
8504   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8505     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8506     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8507     break 2
8508   fi
8509 done
8510   done
8511 IFS=$as_save_IFS
8512 
8513   ;;
8514 esac
8515 fi
8516 MV=$ac_cv_path_MV
8517 if test -n "$MV"; then
8518   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8519 $as_echo "$MV" >&6; }
8520 else
8521   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8522 $as_echo "no" >&6; }
8523 fi
8524 
8525 
8526         if test "x$MV" = x; then
8527           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8528         fi
8529       else
8530         # Otherwise we believe it is a complete path. Use it as it is.
8531         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
8532 $as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
8533         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
8534 $as_echo_n "checking for MV... " >&6; }
8535         if test ! -x "$tool_specified"; then
8536           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8537 $as_echo "not found" >&6; }
8538           as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
8539         fi
8540         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8541 $as_echo "$tool_specified" >&6; }
8542       fi
8543     fi
8544   fi
8545 
8546 
8547 
8548   if test "x$MV" = x; then
8549     as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
8550   fi
8551 
8552 
8553 
8554 
8555 
8556   # Publish this variable in the help.
8557 
8558 
8559   if test "x$NAWK" = x; then
8560     # The variable is not set by user, try to locate tool using the code snippet
8561     for ac_prog in nawk gawk awk
8562 do
8563   # Extract the first word of "$ac_prog", so it can be a program name with args.
8564 set dummy $ac_prog; ac_word=$2
8565 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8566 $as_echo_n "checking for $ac_word... " >&6; }
8567 if ${ac_cv_path_NAWK+:} false; then :
8568   $as_echo_n "(cached) " >&6
8569 else
8570   case $NAWK in
8571   [\\/]* | ?:[\\/]*)
8572   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8573   ;;
8574   *)
8575   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8576 for as_dir in $PATH
8577 do
8578   IFS=$as_save_IFS
8579   test -z "$as_dir" && as_dir=.
8580     for ac_exec_ext in '' $ac_executable_extensions; do
8581   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8582     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8583     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8584     break 2
8585   fi
8586 done
8587   done
8588 IFS=$as_save_IFS
8589 
8590   ;;
8591 esac
8592 fi
8593 NAWK=$ac_cv_path_NAWK
8594 if test -n "$NAWK"; then
8595   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8596 $as_echo "$NAWK" >&6; }
8597 else
8598   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8599 $as_echo "no" >&6; }
8600 fi
8601 
8602 
8603   test -n "$NAWK" && break
8604 done
8605 
8606   else
8607     # The variable is set, but is it from the command line or the environment?
8608 
8609     # Try to remove the string !NAWK! from our list.
8610     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
8611     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8612       # If it failed, the variable was not from the command line. Ignore it,
8613       # but warn the user (except for BASH, which is always set by the calling BASH).
8614       if test "xNAWK" != xBASH; then
8615         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
8616 $as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
8617       fi
8618       # Try to locate tool using the code snippet
8619       for ac_prog in nawk gawk awk
8620 do
8621   # Extract the first word of "$ac_prog", so it can be a program name with args.
8622 set dummy $ac_prog; ac_word=$2
8623 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8624 $as_echo_n "checking for $ac_word... " >&6; }
8625 if ${ac_cv_path_NAWK+:} false; then :
8626   $as_echo_n "(cached) " >&6
8627 else
8628   case $NAWK in
8629   [\\/]* | ?:[\\/]*)
8630   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8631   ;;
8632   *)
8633   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8634 for as_dir in $PATH
8635 do
8636   IFS=$as_save_IFS
8637   test -z "$as_dir" && as_dir=.
8638     for ac_exec_ext in '' $ac_executable_extensions; do
8639   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8640     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8641     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8642     break 2
8643   fi
8644 done
8645   done
8646 IFS=$as_save_IFS
8647 
8648   ;;
8649 esac
8650 fi
8651 NAWK=$ac_cv_path_NAWK
8652 if test -n "$NAWK"; then
8653   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8654 $as_echo "$NAWK" >&6; }
8655 else
8656   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8657 $as_echo "no" >&6; }
8658 fi
8659 
8660 
8661   test -n "$NAWK" && break
8662 done
8663 
8664     else
8665       # If it succeeded, then it was overridden by the user. We will use it
8666       # for the tool.
8667 
8668       # First remove it from the list of overridden variables, so we can test
8669       # for unknown variables in the end.
8670       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8671 
8672       # Check if the provided tool contains a complete path.
8673       tool_specified="$NAWK"
8674       tool_basename="${tool_specified##*/}"
8675       if test "x$tool_basename" = "x$tool_specified"; then
8676         # A command without a complete path is provided, search $PATH.
8677         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
8678 $as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
8679         # Extract the first word of "$tool_basename", so it can be a program name with args.
8680 set dummy $tool_basename; ac_word=$2
8681 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8682 $as_echo_n "checking for $ac_word... " >&6; }
8683 if ${ac_cv_path_NAWK+:} false; then :
8684   $as_echo_n "(cached) " >&6
8685 else
8686   case $NAWK in
8687   [\\/]* | ?:[\\/]*)
8688   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8689   ;;
8690   *)
8691   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8692 for as_dir in $PATH
8693 do
8694   IFS=$as_save_IFS
8695   test -z "$as_dir" && as_dir=.
8696     for ac_exec_ext in '' $ac_executable_extensions; do
8697   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8698     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8699     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8700     break 2
8701   fi
8702 done
8703   done
8704 IFS=$as_save_IFS
8705 
8706   ;;
8707 esac
8708 fi
8709 NAWK=$ac_cv_path_NAWK
8710 if test -n "$NAWK"; then
8711   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8712 $as_echo "$NAWK" >&6; }
8713 else
8714   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8715 $as_echo "no" >&6; }
8716 fi
8717 
8718 
8719         if test "x$NAWK" = x; then
8720           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8721         fi
8722       else
8723         # Otherwise we believe it is a complete path. Use it as it is.
8724         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
8725 $as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
8726         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
8727 $as_echo_n "checking for NAWK... " >&6; }
8728         if test ! -x "$tool_specified"; then
8729           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8730 $as_echo "not found" >&6; }
8731           as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
8732         fi
8733         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8734 $as_echo "$tool_specified" >&6; }
8735       fi
8736     fi
8737   fi
8738 
8739 
8740 
8741   if test "x$NAWK" = x; then
8742     as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
8743   fi
8744 
8745 
8746 
8747 
8748 
8749   # Publish this variable in the help.
8750 
8751 
8752   if test "x$PRINTF" = x; then
8753     # The variable is not set by user, try to locate tool using the code snippet
8754     for ac_prog in printf
8755 do
8756   # Extract the first word of "$ac_prog", so it can be a program name with args.
8757 set dummy $ac_prog; ac_word=$2
8758 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8759 $as_echo_n "checking for $ac_word... " >&6; }
8760 if ${ac_cv_path_PRINTF+:} false; then :
8761   $as_echo_n "(cached) " >&6
8762 else
8763   case $PRINTF in
8764   [\\/]* | ?:[\\/]*)
8765   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8766   ;;
8767   *)
8768   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8769 for as_dir in $PATH
8770 do
8771   IFS=$as_save_IFS
8772   test -z "$as_dir" && as_dir=.
8773     for ac_exec_ext in '' $ac_executable_extensions; do
8774   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8775     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8776     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8777     break 2
8778   fi
8779 done
8780   done
8781 IFS=$as_save_IFS
8782 
8783   ;;
8784 esac
8785 fi
8786 PRINTF=$ac_cv_path_PRINTF
8787 if test -n "$PRINTF"; then
8788   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8789 $as_echo "$PRINTF" >&6; }
8790 else
8791   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8792 $as_echo "no" >&6; }
8793 fi
8794 
8795 
8796   test -n "$PRINTF" && break
8797 done
8798 
8799   else
8800     # The variable is set, but is it from the command line or the environment?
8801 
8802     # Try to remove the string !PRINTF! from our list.
8803     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
8804     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8805       # If it failed, the variable was not from the command line. Ignore it,
8806       # but warn the user (except for BASH, which is always set by the calling BASH).
8807       if test "xPRINTF" != xBASH; then
8808         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
8809 $as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
8810       fi
8811       # Try to locate tool using the code snippet
8812       for ac_prog in printf
8813 do
8814   # Extract the first word of "$ac_prog", so it can be a program name with args.
8815 set dummy $ac_prog; ac_word=$2
8816 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8817 $as_echo_n "checking for $ac_word... " >&6; }
8818 if ${ac_cv_path_PRINTF+:} false; then :
8819   $as_echo_n "(cached) " >&6
8820 else
8821   case $PRINTF in
8822   [\\/]* | ?:[\\/]*)
8823   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8824   ;;
8825   *)
8826   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8827 for as_dir in $PATH
8828 do
8829   IFS=$as_save_IFS
8830   test -z "$as_dir" && as_dir=.
8831     for ac_exec_ext in '' $ac_executable_extensions; do
8832   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8833     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8834     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8835     break 2
8836   fi
8837 done
8838   done
8839 IFS=$as_save_IFS
8840 
8841   ;;
8842 esac
8843 fi
8844 PRINTF=$ac_cv_path_PRINTF
8845 if test -n "$PRINTF"; then
8846   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8847 $as_echo "$PRINTF" >&6; }
8848 else
8849   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8850 $as_echo "no" >&6; }
8851 fi
8852 
8853 
8854   test -n "$PRINTF" && break
8855 done
8856 
8857     else
8858       # If it succeeded, then it was overridden by the user. We will use it
8859       # for the tool.
8860 
8861       # First remove it from the list of overridden variables, so we can test
8862       # for unknown variables in the end.
8863       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8864 
8865       # Check if the provided tool contains a complete path.
8866       tool_specified="$PRINTF"
8867       tool_basename="${tool_specified##*/}"
8868       if test "x$tool_basename" = "x$tool_specified"; then
8869         # A command without a complete path is provided, search $PATH.
8870         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
8871 $as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
8872         # Extract the first word of "$tool_basename", so it can be a program name with args.
8873 set dummy $tool_basename; ac_word=$2
8874 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8875 $as_echo_n "checking for $ac_word... " >&6; }
8876 if ${ac_cv_path_PRINTF+:} false; then :
8877   $as_echo_n "(cached) " >&6
8878 else
8879   case $PRINTF in
8880   [\\/]* | ?:[\\/]*)
8881   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8882   ;;
8883   *)
8884   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8885 for as_dir in $PATH
8886 do
8887   IFS=$as_save_IFS
8888   test -z "$as_dir" && as_dir=.
8889     for ac_exec_ext in '' $ac_executable_extensions; do
8890   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8891     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8892     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8893     break 2
8894   fi
8895 done
8896   done
8897 IFS=$as_save_IFS
8898 
8899   ;;
8900 esac
8901 fi
8902 PRINTF=$ac_cv_path_PRINTF
8903 if test -n "$PRINTF"; then
8904   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8905 $as_echo "$PRINTF" >&6; }
8906 else
8907   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8908 $as_echo "no" >&6; }
8909 fi
8910 
8911 
8912         if test "x$PRINTF" = x; then
8913           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8914         fi
8915       else
8916         # Otherwise we believe it is a complete path. Use it as it is.
8917         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
8918 $as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
8919         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
8920 $as_echo_n "checking for PRINTF... " >&6; }
8921         if test ! -x "$tool_specified"; then
8922           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8923 $as_echo "not found" >&6; }
8924           as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
8925         fi
8926         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8927 $as_echo "$tool_specified" >&6; }
8928       fi
8929     fi
8930   fi
8931 
8932 
8933 
8934   if test "x$PRINTF" = x; then
8935     as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
8936   fi
8937 
8938 
8939 
8940 
8941 
8942   # Publish this variable in the help.
8943 
8944 
8945   if test "x$RM" = x; then
8946     # The variable is not set by user, try to locate tool using the code snippet
8947     for ac_prog in rm
8948 do
8949   # Extract the first word of "$ac_prog", so it can be a program name with args.
8950 set dummy $ac_prog; ac_word=$2
8951 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8952 $as_echo_n "checking for $ac_word... " >&6; }
8953 if ${ac_cv_path_RM+:} false; then :
8954   $as_echo_n "(cached) " >&6
8955 else
8956   case $RM in
8957   [\\/]* | ?:[\\/]*)
8958   ac_cv_path_RM="$RM" # Let the user override the test with a path.
8959   ;;
8960   *)
8961   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8962 for as_dir in $PATH
8963 do
8964   IFS=$as_save_IFS
8965   test -z "$as_dir" && as_dir=.
8966     for ac_exec_ext in '' $ac_executable_extensions; do
8967   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8968     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8969     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8970     break 2
8971   fi
8972 done
8973   done
8974 IFS=$as_save_IFS
8975 
8976   ;;
8977 esac
8978 fi
8979 RM=$ac_cv_path_RM
8980 if test -n "$RM"; then
8981   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8982 $as_echo "$RM" >&6; }
8983 else
8984   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8985 $as_echo "no" >&6; }
8986 fi
8987 
8988 
8989   test -n "$RM" && break
8990 done
8991 
8992   else
8993     # The variable is set, but is it from the command line or the environment?
8994 
8995     # Try to remove the string !RM! from our list.
8996     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
8997     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8998       # If it failed, the variable was not from the command line. Ignore it,
8999       # but warn the user (except for BASH, which is always set by the calling BASH).
9000       if test "xRM" != xBASH; then
9001         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
9002 $as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
9003       fi
9004       # Try to locate tool using the code snippet
9005       for ac_prog in rm
9006 do
9007   # Extract the first word of "$ac_prog", so it can be a program name with args.
9008 set dummy $ac_prog; ac_word=$2
9009 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9010 $as_echo_n "checking for $ac_word... " >&6; }
9011 if ${ac_cv_path_RM+:} false; then :
9012   $as_echo_n "(cached) " >&6
9013 else
9014   case $RM in
9015   [\\/]* | ?:[\\/]*)
9016   ac_cv_path_RM="$RM" # Let the user override the test with a path.
9017   ;;
9018   *)
9019   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9020 for as_dir in $PATH
9021 do
9022   IFS=$as_save_IFS
9023   test -z "$as_dir" && as_dir=.
9024     for ac_exec_ext in '' $ac_executable_extensions; do
9025   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9026     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9027     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9028     break 2
9029   fi
9030 done
9031   done
9032 IFS=$as_save_IFS
9033 
9034   ;;
9035 esac
9036 fi
9037 RM=$ac_cv_path_RM
9038 if test -n "$RM"; then
9039   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9040 $as_echo "$RM" >&6; }
9041 else
9042   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9043 $as_echo "no" >&6; }
9044 fi
9045 
9046 
9047   test -n "$RM" && break
9048 done
9049 
9050     else
9051       # If it succeeded, then it was overridden by the user. We will use it
9052       # for the tool.
9053 
9054       # First remove it from the list of overridden variables, so we can test
9055       # for unknown variables in the end.
9056       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9057 
9058       # Check if the provided tool contains a complete path.
9059       tool_specified="$RM"
9060       tool_basename="${tool_specified##*/}"
9061       if test "x$tool_basename" = "x$tool_specified"; then
9062         # A command without a complete path is provided, search $PATH.
9063         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
9064 $as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
9065         # Extract the first word of "$tool_basename", so it can be a program name with args.
9066 set dummy $tool_basename; ac_word=$2
9067 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9068 $as_echo_n "checking for $ac_word... " >&6; }
9069 if ${ac_cv_path_RM+:} false; then :
9070   $as_echo_n "(cached) " >&6
9071 else
9072   case $RM in
9073   [\\/]* | ?:[\\/]*)
9074   ac_cv_path_RM="$RM" # Let the user override the test with a path.
9075   ;;
9076   *)
9077   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9078 for as_dir in $PATH
9079 do
9080   IFS=$as_save_IFS
9081   test -z "$as_dir" && as_dir=.
9082     for ac_exec_ext in '' $ac_executable_extensions; do
9083   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9084     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9085     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9086     break 2
9087   fi
9088 done
9089   done
9090 IFS=$as_save_IFS
9091 
9092   ;;
9093 esac
9094 fi
9095 RM=$ac_cv_path_RM
9096 if test -n "$RM"; then
9097   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9098 $as_echo "$RM" >&6; }
9099 else
9100   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9101 $as_echo "no" >&6; }
9102 fi
9103 
9104 
9105         if test "x$RM" = x; then
9106           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9107         fi
9108       else
9109         # Otherwise we believe it is a complete path. Use it as it is.
9110         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
9111 $as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
9112         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
9113 $as_echo_n "checking for RM... " >&6; }
9114         if test ! -x "$tool_specified"; then
9115           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9116 $as_echo "not found" >&6; }
9117           as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
9118         fi
9119         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9120 $as_echo "$tool_specified" >&6; }
9121       fi
9122     fi
9123   fi
9124 
9125 
9126 
9127   if test "x$RM" = x; then
9128     as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
9129   fi
9130 
9131 
9132 
9133 
9134 
9135   # Publish this variable in the help.
9136 
9137 
9138   if test "x$SH" = x; then
9139     # The variable is not set by user, try to locate tool using the code snippet
9140     for ac_prog in sh
9141 do
9142   # Extract the first word of "$ac_prog", so it can be a program name with args.
9143 set dummy $ac_prog; ac_word=$2
9144 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9145 $as_echo_n "checking for $ac_word... " >&6; }
9146 if ${ac_cv_path_SH+:} false; then :
9147   $as_echo_n "(cached) " >&6
9148 else
9149   case $SH in
9150   [\\/]* | ?:[\\/]*)
9151   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9152   ;;
9153   *)
9154   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9155 for as_dir in $PATH
9156 do
9157   IFS=$as_save_IFS
9158   test -z "$as_dir" && as_dir=.
9159     for ac_exec_ext in '' $ac_executable_extensions; do
9160   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9161     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9162     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9163     break 2
9164   fi
9165 done
9166   done
9167 IFS=$as_save_IFS
9168 
9169   ;;
9170 esac
9171 fi
9172 SH=$ac_cv_path_SH
9173 if test -n "$SH"; then
9174   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9175 $as_echo "$SH" >&6; }
9176 else
9177   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9178 $as_echo "no" >&6; }
9179 fi
9180 
9181 
9182   test -n "$SH" && break
9183 done
9184 
9185   else
9186     # The variable is set, but is it from the command line or the environment?
9187 
9188     # Try to remove the string !SH! from our list.
9189     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
9190     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9191       # If it failed, the variable was not from the command line. Ignore it,
9192       # but warn the user (except for BASH, which is always set by the calling BASH).
9193       if test "xSH" != xBASH; then
9194         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
9195 $as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
9196       fi
9197       # Try to locate tool using the code snippet
9198       for ac_prog in sh
9199 do
9200   # Extract the first word of "$ac_prog", so it can be a program name with args.
9201 set dummy $ac_prog; ac_word=$2
9202 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9203 $as_echo_n "checking for $ac_word... " >&6; }
9204 if ${ac_cv_path_SH+:} false; then :
9205   $as_echo_n "(cached) " >&6
9206 else
9207   case $SH in
9208   [\\/]* | ?:[\\/]*)
9209   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9210   ;;
9211   *)
9212   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9213 for as_dir in $PATH
9214 do
9215   IFS=$as_save_IFS
9216   test -z "$as_dir" && as_dir=.
9217     for ac_exec_ext in '' $ac_executable_extensions; do
9218   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9219     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9220     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9221     break 2
9222   fi
9223 done
9224   done
9225 IFS=$as_save_IFS
9226 
9227   ;;
9228 esac
9229 fi
9230 SH=$ac_cv_path_SH
9231 if test -n "$SH"; then
9232   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9233 $as_echo "$SH" >&6; }
9234 else
9235   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9236 $as_echo "no" >&6; }
9237 fi
9238 
9239 
9240   test -n "$SH" && break
9241 done
9242 
9243     else
9244       # If it succeeded, then it was overridden by the user. We will use it
9245       # for the tool.
9246 
9247       # First remove it from the list of overridden variables, so we can test
9248       # for unknown variables in the end.
9249       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9250 
9251       # Check if the provided tool contains a complete path.
9252       tool_specified="$SH"
9253       tool_basename="${tool_specified##*/}"
9254       if test "x$tool_basename" = "x$tool_specified"; then
9255         # A command without a complete path is provided, search $PATH.
9256         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
9257 $as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
9258         # Extract the first word of "$tool_basename", so it can be a program name with args.
9259 set dummy $tool_basename; ac_word=$2
9260 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9261 $as_echo_n "checking for $ac_word... " >&6; }
9262 if ${ac_cv_path_SH+:} false; then :
9263   $as_echo_n "(cached) " >&6
9264 else
9265   case $SH in
9266   [\\/]* | ?:[\\/]*)
9267   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9268   ;;
9269   *)
9270   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9271 for as_dir in $PATH
9272 do
9273   IFS=$as_save_IFS
9274   test -z "$as_dir" && as_dir=.
9275     for ac_exec_ext in '' $ac_executable_extensions; do
9276   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9277     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9278     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9279     break 2
9280   fi
9281 done
9282   done
9283 IFS=$as_save_IFS
9284 
9285   ;;
9286 esac
9287 fi
9288 SH=$ac_cv_path_SH
9289 if test -n "$SH"; then
9290   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9291 $as_echo "$SH" >&6; }
9292 else
9293   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9294 $as_echo "no" >&6; }
9295 fi
9296 
9297 
9298         if test "x$SH" = x; then
9299           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9300         fi
9301       else
9302         # Otherwise we believe it is a complete path. Use it as it is.
9303         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
9304 $as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
9305         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
9306 $as_echo_n "checking for SH... " >&6; }
9307         if test ! -x "$tool_specified"; then
9308           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9309 $as_echo "not found" >&6; }
9310           as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
9311         fi
9312         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9313 $as_echo "$tool_specified" >&6; }
9314       fi
9315     fi
9316   fi
9317 
9318 
9319 
9320   if test "x$SH" = x; then
9321     as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
9322   fi
9323 
9324 
9325 
9326 
9327 
9328   # Publish this variable in the help.
9329 
9330 
9331   if test "x$SORT" = x; then
9332     # The variable is not set by user, try to locate tool using the code snippet
9333     for ac_prog in sort
9334 do
9335   # Extract the first word of "$ac_prog", so it can be a program name with args.
9336 set dummy $ac_prog; ac_word=$2
9337 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9338 $as_echo_n "checking for $ac_word... " >&6; }
9339 if ${ac_cv_path_SORT+:} false; then :
9340   $as_echo_n "(cached) " >&6
9341 else
9342   case $SORT in
9343   [\\/]* | ?:[\\/]*)
9344   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9345   ;;
9346   *)
9347   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9348 for as_dir in $PATH
9349 do
9350   IFS=$as_save_IFS
9351   test -z "$as_dir" && as_dir=.
9352     for ac_exec_ext in '' $ac_executable_extensions; do
9353   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9354     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9355     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9356     break 2
9357   fi
9358 done
9359   done
9360 IFS=$as_save_IFS
9361 
9362   ;;
9363 esac
9364 fi
9365 SORT=$ac_cv_path_SORT
9366 if test -n "$SORT"; then
9367   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9368 $as_echo "$SORT" >&6; }
9369 else
9370   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9371 $as_echo "no" >&6; }
9372 fi
9373 
9374 
9375   test -n "$SORT" && break
9376 done
9377 
9378   else
9379     # The variable is set, but is it from the command line or the environment?
9380 
9381     # Try to remove the string !SORT! from our list.
9382     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
9383     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9384       # If it failed, the variable was not from the command line. Ignore it,
9385       # but warn the user (except for BASH, which is always set by the calling BASH).
9386       if test "xSORT" != xBASH; then
9387         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
9388 $as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
9389       fi
9390       # Try to locate tool using the code snippet
9391       for ac_prog in sort
9392 do
9393   # Extract the first word of "$ac_prog", so it can be a program name with args.
9394 set dummy $ac_prog; ac_word=$2
9395 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9396 $as_echo_n "checking for $ac_word... " >&6; }
9397 if ${ac_cv_path_SORT+:} false; then :
9398   $as_echo_n "(cached) " >&6
9399 else
9400   case $SORT in
9401   [\\/]* | ?:[\\/]*)
9402   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9403   ;;
9404   *)
9405   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9406 for as_dir in $PATH
9407 do
9408   IFS=$as_save_IFS
9409   test -z "$as_dir" && as_dir=.
9410     for ac_exec_ext in '' $ac_executable_extensions; do
9411   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9412     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9413     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9414     break 2
9415   fi
9416 done
9417   done
9418 IFS=$as_save_IFS
9419 
9420   ;;
9421 esac
9422 fi
9423 SORT=$ac_cv_path_SORT
9424 if test -n "$SORT"; then
9425   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9426 $as_echo "$SORT" >&6; }
9427 else
9428   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9429 $as_echo "no" >&6; }
9430 fi
9431 
9432 
9433   test -n "$SORT" && break
9434 done
9435 
9436     else
9437       # If it succeeded, then it was overridden by the user. We will use it
9438       # for the tool.
9439 
9440       # First remove it from the list of overridden variables, so we can test
9441       # for unknown variables in the end.
9442       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9443 
9444       # Check if the provided tool contains a complete path.
9445       tool_specified="$SORT"
9446       tool_basename="${tool_specified##*/}"
9447       if test "x$tool_basename" = "x$tool_specified"; then
9448         # A command without a complete path is provided, search $PATH.
9449         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
9450 $as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
9451         # Extract the first word of "$tool_basename", so it can be a program name with args.
9452 set dummy $tool_basename; ac_word=$2
9453 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9454 $as_echo_n "checking for $ac_word... " >&6; }
9455 if ${ac_cv_path_SORT+:} false; then :
9456   $as_echo_n "(cached) " >&6
9457 else
9458   case $SORT in
9459   [\\/]* | ?:[\\/]*)
9460   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9461   ;;
9462   *)
9463   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9464 for as_dir in $PATH
9465 do
9466   IFS=$as_save_IFS
9467   test -z "$as_dir" && as_dir=.
9468     for ac_exec_ext in '' $ac_executable_extensions; do
9469   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9470     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9471     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9472     break 2
9473   fi
9474 done
9475   done
9476 IFS=$as_save_IFS
9477 
9478   ;;
9479 esac
9480 fi
9481 SORT=$ac_cv_path_SORT
9482 if test -n "$SORT"; then
9483   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9484 $as_echo "$SORT" >&6; }
9485 else
9486   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9487 $as_echo "no" >&6; }
9488 fi
9489 
9490 
9491         if test "x$SORT" = x; then
9492           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9493         fi
9494       else
9495         # Otherwise we believe it is a complete path. Use it as it is.
9496         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
9497 $as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
9498         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
9499 $as_echo_n "checking for SORT... " >&6; }
9500         if test ! -x "$tool_specified"; then
9501           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9502 $as_echo "not found" >&6; }
9503           as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
9504         fi
9505         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9506 $as_echo "$tool_specified" >&6; }
9507       fi
9508     fi
9509   fi
9510 
9511 
9512 
9513   if test "x$SORT" = x; then
9514     as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
9515   fi
9516 
9517 
9518 
9519 
9520 
9521   # Publish this variable in the help.
9522 
9523 
9524   if test "x$TAIL" = x; then
9525     # The variable is not set by user, try to locate tool using the code snippet
9526     for ac_prog in tail
9527 do
9528   # Extract the first word of "$ac_prog", so it can be a program name with args.
9529 set dummy $ac_prog; ac_word=$2
9530 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9531 $as_echo_n "checking for $ac_word... " >&6; }
9532 if ${ac_cv_path_TAIL+:} false; then :
9533   $as_echo_n "(cached) " >&6
9534 else
9535   case $TAIL in
9536   [\\/]* | ?:[\\/]*)
9537   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9538   ;;
9539   *)
9540   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9541 for as_dir in $PATH
9542 do
9543   IFS=$as_save_IFS
9544   test -z "$as_dir" && as_dir=.
9545     for ac_exec_ext in '' $ac_executable_extensions; do
9546   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9547     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9548     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9549     break 2
9550   fi
9551 done
9552   done
9553 IFS=$as_save_IFS
9554 
9555   ;;
9556 esac
9557 fi
9558 TAIL=$ac_cv_path_TAIL
9559 if test -n "$TAIL"; then
9560   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9561 $as_echo "$TAIL" >&6; }
9562 else
9563   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9564 $as_echo "no" >&6; }
9565 fi
9566 
9567 
9568   test -n "$TAIL" && break
9569 done
9570 
9571   else
9572     # The variable is set, but is it from the command line or the environment?
9573 
9574     # Try to remove the string !TAIL! from our list.
9575     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
9576     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9577       # If it failed, the variable was not from the command line. Ignore it,
9578       # but warn the user (except for BASH, which is always set by the calling BASH).
9579       if test "xTAIL" != xBASH; then
9580         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
9581 $as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
9582       fi
9583       # Try to locate tool using the code snippet
9584       for ac_prog in tail
9585 do
9586   # Extract the first word of "$ac_prog", so it can be a program name with args.
9587 set dummy $ac_prog; ac_word=$2
9588 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9589 $as_echo_n "checking for $ac_word... " >&6; }
9590 if ${ac_cv_path_TAIL+:} false; then :
9591   $as_echo_n "(cached) " >&6
9592 else
9593   case $TAIL in
9594   [\\/]* | ?:[\\/]*)
9595   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9596   ;;
9597   *)
9598   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9599 for as_dir in $PATH
9600 do
9601   IFS=$as_save_IFS
9602   test -z "$as_dir" && as_dir=.
9603     for ac_exec_ext in '' $ac_executable_extensions; do
9604   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9605     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9606     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9607     break 2
9608   fi
9609 done
9610   done
9611 IFS=$as_save_IFS
9612 
9613   ;;
9614 esac
9615 fi
9616 TAIL=$ac_cv_path_TAIL
9617 if test -n "$TAIL"; then
9618   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9619 $as_echo "$TAIL" >&6; }
9620 else
9621   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9622 $as_echo "no" >&6; }
9623 fi
9624 
9625 
9626   test -n "$TAIL" && break
9627 done
9628 
9629     else
9630       # If it succeeded, then it was overridden by the user. We will use it
9631       # for the tool.
9632 
9633       # First remove it from the list of overridden variables, so we can test
9634       # for unknown variables in the end.
9635       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9636 
9637       # Check if the provided tool contains a complete path.
9638       tool_specified="$TAIL"
9639       tool_basename="${tool_specified##*/}"
9640       if test "x$tool_basename" = "x$tool_specified"; then
9641         # A command without a complete path is provided, search $PATH.
9642         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
9643 $as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
9644         # Extract the first word of "$tool_basename", so it can be a program name with args.
9645 set dummy $tool_basename; ac_word=$2
9646 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9647 $as_echo_n "checking for $ac_word... " >&6; }
9648 if ${ac_cv_path_TAIL+:} false; then :
9649   $as_echo_n "(cached) " >&6
9650 else
9651   case $TAIL in
9652   [\\/]* | ?:[\\/]*)
9653   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9654   ;;
9655   *)
9656   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9657 for as_dir in $PATH
9658 do
9659   IFS=$as_save_IFS
9660   test -z "$as_dir" && as_dir=.
9661     for ac_exec_ext in '' $ac_executable_extensions; do
9662   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9663     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9664     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9665     break 2
9666   fi
9667 done
9668   done
9669 IFS=$as_save_IFS
9670 
9671   ;;
9672 esac
9673 fi
9674 TAIL=$ac_cv_path_TAIL
9675 if test -n "$TAIL"; then
9676   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9677 $as_echo "$TAIL" >&6; }
9678 else
9679   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9680 $as_echo "no" >&6; }
9681 fi
9682 
9683 
9684         if test "x$TAIL" = x; then
9685           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9686         fi
9687       else
9688         # Otherwise we believe it is a complete path. Use it as it is.
9689         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
9690 $as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
9691         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
9692 $as_echo_n "checking for TAIL... " >&6; }
9693         if test ! -x "$tool_specified"; then
9694           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9695 $as_echo "not found" >&6; }
9696           as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
9697         fi
9698         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9699 $as_echo "$tool_specified" >&6; }
9700       fi
9701     fi
9702   fi
9703 
9704 
9705 
9706   if test "x$TAIL" = x; then
9707     as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
9708   fi
9709 
9710 
9711 
9712 
9713 
9714   # Publish this variable in the help.
9715 
9716 
9717   if test "x$TAR" = x; then
9718     # The variable is not set by user, try to locate tool using the code snippet
9719     for ac_prog in tar
9720 do
9721   # Extract the first word of "$ac_prog", so it can be a program name with args.
9722 set dummy $ac_prog; ac_word=$2
9723 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9724 $as_echo_n "checking for $ac_word... " >&6; }
9725 if ${ac_cv_path_TAR+:} false; then :
9726   $as_echo_n "(cached) " >&6
9727 else
9728   case $TAR in
9729   [\\/]* | ?:[\\/]*)
9730   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9731   ;;
9732   *)
9733   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9734 for as_dir in $PATH
9735 do
9736   IFS=$as_save_IFS
9737   test -z "$as_dir" && as_dir=.
9738     for ac_exec_ext in '' $ac_executable_extensions; do
9739   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9740     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9741     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9742     break 2
9743   fi
9744 done
9745   done
9746 IFS=$as_save_IFS
9747 
9748   ;;
9749 esac
9750 fi
9751 TAR=$ac_cv_path_TAR
9752 if test -n "$TAR"; then
9753   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9754 $as_echo "$TAR" >&6; }
9755 else
9756   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9757 $as_echo "no" >&6; }
9758 fi
9759 
9760 
9761   test -n "$TAR" && break
9762 done
9763 
9764   else
9765     # The variable is set, but is it from the command line or the environment?
9766 
9767     # Try to remove the string !TAR! from our list.
9768     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
9769     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9770       # If it failed, the variable was not from the command line. Ignore it,
9771       # but warn the user (except for BASH, which is always set by the calling BASH).
9772       if test "xTAR" != xBASH; then
9773         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
9774 $as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
9775       fi
9776       # Try to locate tool using the code snippet
9777       for ac_prog in tar
9778 do
9779   # Extract the first word of "$ac_prog", so it can be a program name with args.
9780 set dummy $ac_prog; ac_word=$2
9781 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9782 $as_echo_n "checking for $ac_word... " >&6; }
9783 if ${ac_cv_path_TAR+:} false; then :
9784   $as_echo_n "(cached) " >&6
9785 else
9786   case $TAR in
9787   [\\/]* | ?:[\\/]*)
9788   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9789   ;;
9790   *)
9791   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9792 for as_dir in $PATH
9793 do
9794   IFS=$as_save_IFS
9795   test -z "$as_dir" && as_dir=.
9796     for ac_exec_ext in '' $ac_executable_extensions; do
9797   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9798     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9799     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9800     break 2
9801   fi
9802 done
9803   done
9804 IFS=$as_save_IFS
9805 
9806   ;;
9807 esac
9808 fi
9809 TAR=$ac_cv_path_TAR
9810 if test -n "$TAR"; then
9811   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9812 $as_echo "$TAR" >&6; }
9813 else
9814   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9815 $as_echo "no" >&6; }
9816 fi
9817 
9818 
9819   test -n "$TAR" && break
9820 done
9821 
9822     else
9823       # If it succeeded, then it was overridden by the user. We will use it
9824       # for the tool.
9825 
9826       # First remove it from the list of overridden variables, so we can test
9827       # for unknown variables in the end.
9828       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9829 
9830       # Check if the provided tool contains a complete path.
9831       tool_specified="$TAR"
9832       tool_basename="${tool_specified##*/}"
9833       if test "x$tool_basename" = "x$tool_specified"; then
9834         # A command without a complete path is provided, search $PATH.
9835         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
9836 $as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
9837         # Extract the first word of "$tool_basename", so it can be a program name with args.
9838 set dummy $tool_basename; ac_word=$2
9839 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9840 $as_echo_n "checking for $ac_word... " >&6; }
9841 if ${ac_cv_path_TAR+:} false; then :
9842   $as_echo_n "(cached) " >&6
9843 else
9844   case $TAR in
9845   [\\/]* | ?:[\\/]*)
9846   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9847   ;;
9848   *)
9849   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9850 for as_dir in $PATH
9851 do
9852   IFS=$as_save_IFS
9853   test -z "$as_dir" && as_dir=.
9854     for ac_exec_ext in '' $ac_executable_extensions; do
9855   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9856     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9857     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9858     break 2
9859   fi
9860 done
9861   done
9862 IFS=$as_save_IFS
9863 
9864   ;;
9865 esac
9866 fi
9867 TAR=$ac_cv_path_TAR
9868 if test -n "$TAR"; then
9869   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9870 $as_echo "$TAR" >&6; }
9871 else
9872   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9873 $as_echo "no" >&6; }
9874 fi
9875 
9876 
9877         if test "x$TAR" = x; then
9878           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9879         fi
9880       else
9881         # Otherwise we believe it is a complete path. Use it as it is.
9882         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
9883 $as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
9884         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
9885 $as_echo_n "checking for TAR... " >&6; }
9886         if test ! -x "$tool_specified"; then
9887           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9888 $as_echo "not found" >&6; }
9889           as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
9890         fi
9891         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9892 $as_echo "$tool_specified" >&6; }
9893       fi
9894     fi
9895   fi
9896 
9897 
9898 
9899   if test "x$TAR" = x; then
9900     as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
9901   fi
9902 
9903 
9904 
9905 
9906 
9907   # Publish this variable in the help.
9908 
9909 
9910   if test "x$TEE" = x; then
9911     # The variable is not set by user, try to locate tool using the code snippet
9912     for ac_prog in tee
9913 do
9914   # Extract the first word of "$ac_prog", so it can be a program name with args.
9915 set dummy $ac_prog; ac_word=$2
9916 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9917 $as_echo_n "checking for $ac_word... " >&6; }
9918 if ${ac_cv_path_TEE+:} false; then :
9919   $as_echo_n "(cached) " >&6
9920 else
9921   case $TEE in
9922   [\\/]* | ?:[\\/]*)
9923   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9924   ;;
9925   *)
9926   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9927 for as_dir in $PATH
9928 do
9929   IFS=$as_save_IFS
9930   test -z "$as_dir" && as_dir=.
9931     for ac_exec_ext in '' $ac_executable_extensions; do
9932   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9933     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9934     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9935     break 2
9936   fi
9937 done
9938   done
9939 IFS=$as_save_IFS
9940 
9941   ;;
9942 esac
9943 fi
9944 TEE=$ac_cv_path_TEE
9945 if test -n "$TEE"; then
9946   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9947 $as_echo "$TEE" >&6; }
9948 else
9949   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9950 $as_echo "no" >&6; }
9951 fi
9952 
9953 
9954   test -n "$TEE" && break
9955 done
9956 
9957   else
9958     # The variable is set, but is it from the command line or the environment?
9959 
9960     # Try to remove the string !TEE! from our list.
9961     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
9962     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9963       # If it failed, the variable was not from the command line. Ignore it,
9964       # but warn the user (except for BASH, which is always set by the calling BASH).
9965       if test "xTEE" != xBASH; then
9966         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
9967 $as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
9968       fi
9969       # Try to locate tool using the code snippet
9970       for ac_prog in tee
9971 do
9972   # Extract the first word of "$ac_prog", so it can be a program name with args.
9973 set dummy $ac_prog; ac_word=$2
9974 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9975 $as_echo_n "checking for $ac_word... " >&6; }
9976 if ${ac_cv_path_TEE+:} false; then :
9977   $as_echo_n "(cached) " >&6
9978 else
9979   case $TEE in
9980   [\\/]* | ?:[\\/]*)
9981   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9982   ;;
9983   *)
9984   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9985 for as_dir in $PATH
9986 do
9987   IFS=$as_save_IFS
9988   test -z "$as_dir" && as_dir=.
9989     for ac_exec_ext in '' $ac_executable_extensions; do
9990   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9991     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9992     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9993     break 2
9994   fi
9995 done
9996   done
9997 IFS=$as_save_IFS
9998 
9999   ;;
10000 esac
10001 fi
10002 TEE=$ac_cv_path_TEE
10003 if test -n "$TEE"; then
10004   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
10005 $as_echo "$TEE" >&6; }
10006 else
10007   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10008 $as_echo "no" >&6; }
10009 fi
10010 
10011 
10012   test -n "$TEE" && break
10013 done
10014 
10015     else
10016       # If it succeeded, then it was overridden by the user. We will use it
10017       # for the tool.
10018 
10019       # First remove it from the list of overridden variables, so we can test
10020       # for unknown variables in the end.
10021       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10022 
10023       # Check if the provided tool contains a complete path.
10024       tool_specified="$TEE"
10025       tool_basename="${tool_specified##*/}"
10026       if test "x$tool_basename" = "x$tool_specified"; then
10027         # A command without a complete path is provided, search $PATH.
10028         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
10029 $as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
10030         # Extract the first word of "$tool_basename", so it can be a program name with args.
10031 set dummy $tool_basename; ac_word=$2
10032 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10033 $as_echo_n "checking for $ac_word... " >&6; }
10034 if ${ac_cv_path_TEE+:} false; then :
10035   $as_echo_n "(cached) " >&6
10036 else
10037   case $TEE in
10038   [\\/]* | ?:[\\/]*)
10039   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
10040   ;;
10041   *)
10042   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10043 for as_dir in $PATH
10044 do
10045   IFS=$as_save_IFS
10046   test -z "$as_dir" && as_dir=.
10047     for ac_exec_ext in '' $ac_executable_extensions; do
10048   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10049     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
10050     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10051     break 2
10052   fi
10053 done
10054   done
10055 IFS=$as_save_IFS
10056 
10057   ;;
10058 esac
10059 fi
10060 TEE=$ac_cv_path_TEE
10061 if test -n "$TEE"; then
10062   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
10063 $as_echo "$TEE" >&6; }
10064 else
10065   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10066 $as_echo "no" >&6; }
10067 fi
10068 
10069 
10070         if test "x$TEE" = x; then
10071           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10072         fi
10073       else
10074         # Otherwise we believe it is a complete path. Use it as it is.
10075         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
10076 $as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
10077         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
10078 $as_echo_n "checking for TEE... " >&6; }
10079         if test ! -x "$tool_specified"; then
10080           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10081 $as_echo "not found" >&6; }
10082           as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
10083         fi
10084         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10085 $as_echo "$tool_specified" >&6; }
10086       fi
10087     fi
10088   fi
10089 
10090 
10091 
10092   if test "x$TEE" = x; then
10093     as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
10094   fi
10095 
10096 
10097 
10098 
10099 
10100   # Publish this variable in the help.
10101 
10102 
10103   if test "x$TOUCH" = x; then
10104     # The variable is not set by user, try to locate tool using the code snippet
10105     for ac_prog in touch
10106 do
10107   # Extract the first word of "$ac_prog", so it can be a program name with args.
10108 set dummy $ac_prog; ac_word=$2
10109 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10110 $as_echo_n "checking for $ac_word... " >&6; }
10111 if ${ac_cv_path_TOUCH+:} false; then :
10112   $as_echo_n "(cached) " >&6
10113 else
10114   case $TOUCH in
10115   [\\/]* | ?:[\\/]*)
10116   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10117   ;;
10118   *)
10119   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10120 for as_dir in $PATH
10121 do
10122   IFS=$as_save_IFS
10123   test -z "$as_dir" && as_dir=.
10124     for ac_exec_ext in '' $ac_executable_extensions; do
10125   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10126     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10127     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10128     break 2
10129   fi
10130 done
10131   done
10132 IFS=$as_save_IFS
10133 
10134   ;;
10135 esac
10136 fi
10137 TOUCH=$ac_cv_path_TOUCH
10138 if test -n "$TOUCH"; then
10139   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10140 $as_echo "$TOUCH" >&6; }
10141 else
10142   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10143 $as_echo "no" >&6; }
10144 fi
10145 
10146 
10147   test -n "$TOUCH" && break
10148 done
10149 
10150   else
10151     # The variable is set, but is it from the command line or the environment?
10152 
10153     # Try to remove the string !TOUCH! from our list.
10154     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
10155     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10156       # If it failed, the variable was not from the command line. Ignore it,
10157       # but warn the user (except for BASH, which is always set by the calling BASH).
10158       if test "xTOUCH" != xBASH; then
10159         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
10160 $as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
10161       fi
10162       # Try to locate tool using the code snippet
10163       for ac_prog in touch
10164 do
10165   # Extract the first word of "$ac_prog", so it can be a program name with args.
10166 set dummy $ac_prog; ac_word=$2
10167 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10168 $as_echo_n "checking for $ac_word... " >&6; }
10169 if ${ac_cv_path_TOUCH+:} false; then :
10170   $as_echo_n "(cached) " >&6
10171 else
10172   case $TOUCH in
10173   [\\/]* | ?:[\\/]*)
10174   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10175   ;;
10176   *)
10177   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10178 for as_dir in $PATH
10179 do
10180   IFS=$as_save_IFS
10181   test -z "$as_dir" && as_dir=.
10182     for ac_exec_ext in '' $ac_executable_extensions; do
10183   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10184     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10185     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10186     break 2
10187   fi
10188 done
10189   done
10190 IFS=$as_save_IFS
10191 
10192   ;;
10193 esac
10194 fi
10195 TOUCH=$ac_cv_path_TOUCH
10196 if test -n "$TOUCH"; then
10197   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10198 $as_echo "$TOUCH" >&6; }
10199 else
10200   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10201 $as_echo "no" >&6; }
10202 fi
10203 
10204 
10205   test -n "$TOUCH" && break
10206 done
10207 
10208     else
10209       # If it succeeded, then it was overridden by the user. We will use it
10210       # for the tool.
10211 
10212       # First remove it from the list of overridden variables, so we can test
10213       # for unknown variables in the end.
10214       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10215 
10216       # Check if the provided tool contains a complete path.
10217       tool_specified="$TOUCH"
10218       tool_basename="${tool_specified##*/}"
10219       if test "x$tool_basename" = "x$tool_specified"; then
10220         # A command without a complete path is provided, search $PATH.
10221         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
10222 $as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
10223         # Extract the first word of "$tool_basename", so it can be a program name with args.
10224 set dummy $tool_basename; ac_word=$2
10225 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10226 $as_echo_n "checking for $ac_word... " >&6; }
10227 if ${ac_cv_path_TOUCH+:} false; then :
10228   $as_echo_n "(cached) " >&6
10229 else
10230   case $TOUCH in
10231   [\\/]* | ?:[\\/]*)
10232   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10233   ;;
10234   *)
10235   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10236 for as_dir in $PATH
10237 do
10238   IFS=$as_save_IFS
10239   test -z "$as_dir" && as_dir=.
10240     for ac_exec_ext in '' $ac_executable_extensions; do
10241   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10242     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10243     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10244     break 2
10245   fi
10246 done
10247   done
10248 IFS=$as_save_IFS
10249 
10250   ;;
10251 esac
10252 fi
10253 TOUCH=$ac_cv_path_TOUCH
10254 if test -n "$TOUCH"; then
10255   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10256 $as_echo "$TOUCH" >&6; }
10257 else
10258   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10259 $as_echo "no" >&6; }
10260 fi
10261 
10262 
10263         if test "x$TOUCH" = x; then
10264           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10265         fi
10266       else
10267         # Otherwise we believe it is a complete path. Use it as it is.
10268         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
10269 $as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
10270         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
10271 $as_echo_n "checking for TOUCH... " >&6; }
10272         if test ! -x "$tool_specified"; then
10273           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10274 $as_echo "not found" >&6; }
10275           as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
10276         fi
10277         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10278 $as_echo "$tool_specified" >&6; }
10279       fi
10280     fi
10281   fi
10282 
10283 
10284 
10285   if test "x$TOUCH" = x; then
10286     as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
10287   fi
10288 
10289 
10290 
10291 
10292 
10293   # Publish this variable in the help.
10294 
10295 
10296   if test "x$TR" = x; then
10297     # The variable is not set by user, try to locate tool using the code snippet
10298     for ac_prog in tr
10299 do
10300   # Extract the first word of "$ac_prog", so it can be a program name with args.
10301 set dummy $ac_prog; ac_word=$2
10302 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10303 $as_echo_n "checking for $ac_word... " >&6; }
10304 if ${ac_cv_path_TR+:} false; then :
10305   $as_echo_n "(cached) " >&6
10306 else
10307   case $TR in
10308   [\\/]* | ?:[\\/]*)
10309   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10310   ;;
10311   *)
10312   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10313 for as_dir in $PATH
10314 do
10315   IFS=$as_save_IFS
10316   test -z "$as_dir" && as_dir=.
10317     for ac_exec_ext in '' $ac_executable_extensions; do
10318   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10319     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10320     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10321     break 2
10322   fi
10323 done
10324   done
10325 IFS=$as_save_IFS
10326 
10327   ;;
10328 esac
10329 fi
10330 TR=$ac_cv_path_TR
10331 if test -n "$TR"; then
10332   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10333 $as_echo "$TR" >&6; }
10334 else
10335   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10336 $as_echo "no" >&6; }
10337 fi
10338 
10339 
10340   test -n "$TR" && break
10341 done
10342 
10343   else
10344     # The variable is set, but is it from the command line or the environment?
10345 
10346     # Try to remove the string !TR! from our list.
10347     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
10348     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10349       # If it failed, the variable was not from the command line. Ignore it,
10350       # but warn the user (except for BASH, which is always set by the calling BASH).
10351       if test "xTR" != xBASH; then
10352         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
10353 $as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
10354       fi
10355       # Try to locate tool using the code snippet
10356       for ac_prog in tr
10357 do
10358   # Extract the first word of "$ac_prog", so it can be a program name with args.
10359 set dummy $ac_prog; ac_word=$2
10360 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10361 $as_echo_n "checking for $ac_word... " >&6; }
10362 if ${ac_cv_path_TR+:} false; then :
10363   $as_echo_n "(cached) " >&6
10364 else
10365   case $TR in
10366   [\\/]* | ?:[\\/]*)
10367   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10368   ;;
10369   *)
10370   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10371 for as_dir in $PATH
10372 do
10373   IFS=$as_save_IFS
10374   test -z "$as_dir" && as_dir=.
10375     for ac_exec_ext in '' $ac_executable_extensions; do
10376   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10377     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10378     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10379     break 2
10380   fi
10381 done
10382   done
10383 IFS=$as_save_IFS
10384 
10385   ;;
10386 esac
10387 fi
10388 TR=$ac_cv_path_TR
10389 if test -n "$TR"; then
10390   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10391 $as_echo "$TR" >&6; }
10392 else
10393   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10394 $as_echo "no" >&6; }
10395 fi
10396 
10397 
10398   test -n "$TR" && break
10399 done
10400 
10401     else
10402       # If it succeeded, then it was overridden by the user. We will use it
10403       # for the tool.
10404 
10405       # First remove it from the list of overridden variables, so we can test
10406       # for unknown variables in the end.
10407       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10408 
10409       # Check if the provided tool contains a complete path.
10410       tool_specified="$TR"
10411       tool_basename="${tool_specified##*/}"
10412       if test "x$tool_basename" = "x$tool_specified"; then
10413         # A command without a complete path is provided, search $PATH.
10414         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
10415 $as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
10416         # Extract the first word of "$tool_basename", so it can be a program name with args.
10417 set dummy $tool_basename; ac_word=$2
10418 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10419 $as_echo_n "checking for $ac_word... " >&6; }
10420 if ${ac_cv_path_TR+:} false; then :
10421   $as_echo_n "(cached) " >&6
10422 else
10423   case $TR in
10424   [\\/]* | ?:[\\/]*)
10425   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10426   ;;
10427   *)
10428   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10429 for as_dir in $PATH
10430 do
10431   IFS=$as_save_IFS
10432   test -z "$as_dir" && as_dir=.
10433     for ac_exec_ext in '' $ac_executable_extensions; do
10434   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10435     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10436     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10437     break 2
10438   fi
10439 done
10440   done
10441 IFS=$as_save_IFS
10442 
10443   ;;
10444 esac
10445 fi
10446 TR=$ac_cv_path_TR
10447 if test -n "$TR"; then
10448   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10449 $as_echo "$TR" >&6; }
10450 else
10451   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10452 $as_echo "no" >&6; }
10453 fi
10454 
10455 
10456         if test "x$TR" = x; then
10457           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10458         fi
10459       else
10460         # Otherwise we believe it is a complete path. Use it as it is.
10461         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
10462 $as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
10463         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
10464 $as_echo_n "checking for TR... " >&6; }
10465         if test ! -x "$tool_specified"; then
10466           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10467 $as_echo "not found" >&6; }
10468           as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
10469         fi
10470         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10471 $as_echo "$tool_specified" >&6; }
10472       fi
10473     fi
10474   fi
10475 
10476 
10477 
10478   if test "x$TR" = x; then
10479     as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
10480   fi
10481 
10482 
10483 
10484 
10485 
10486   # Publish this variable in the help.
10487 
10488 
10489   if test "x$UNAME" = x; then
10490     # The variable is not set by user, try to locate tool using the code snippet
10491     for ac_prog in uname
10492 do
10493   # Extract the first word of "$ac_prog", so it can be a program name with args.
10494 set dummy $ac_prog; ac_word=$2
10495 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10496 $as_echo_n "checking for $ac_word... " >&6; }
10497 if ${ac_cv_path_UNAME+:} false; then :
10498   $as_echo_n "(cached) " >&6
10499 else
10500   case $UNAME in
10501   [\\/]* | ?:[\\/]*)
10502   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10503   ;;
10504   *)
10505   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10506 for as_dir in $PATH
10507 do
10508   IFS=$as_save_IFS
10509   test -z "$as_dir" && as_dir=.
10510     for ac_exec_ext in '' $ac_executable_extensions; do
10511   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10512     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10513     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10514     break 2
10515   fi
10516 done
10517   done
10518 IFS=$as_save_IFS
10519 
10520   ;;
10521 esac
10522 fi
10523 UNAME=$ac_cv_path_UNAME
10524 if test -n "$UNAME"; then
10525   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10526 $as_echo "$UNAME" >&6; }
10527 else
10528   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10529 $as_echo "no" >&6; }
10530 fi
10531 
10532 
10533   test -n "$UNAME" && break
10534 done
10535 
10536   else
10537     # The variable is set, but is it from the command line or the environment?
10538 
10539     # Try to remove the string !UNAME! from our list.
10540     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
10541     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10542       # If it failed, the variable was not from the command line. Ignore it,
10543       # but warn the user (except for BASH, which is always set by the calling BASH).
10544       if test "xUNAME" != xBASH; then
10545         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
10546 $as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
10547       fi
10548       # Try to locate tool using the code snippet
10549       for ac_prog in uname
10550 do
10551   # Extract the first word of "$ac_prog", so it can be a program name with args.
10552 set dummy $ac_prog; ac_word=$2
10553 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10554 $as_echo_n "checking for $ac_word... " >&6; }
10555 if ${ac_cv_path_UNAME+:} false; then :
10556   $as_echo_n "(cached) " >&6
10557 else
10558   case $UNAME in
10559   [\\/]* | ?:[\\/]*)
10560   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10561   ;;
10562   *)
10563   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10564 for as_dir in $PATH
10565 do
10566   IFS=$as_save_IFS
10567   test -z "$as_dir" && as_dir=.
10568     for ac_exec_ext in '' $ac_executable_extensions; do
10569   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10570     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10571     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10572     break 2
10573   fi
10574 done
10575   done
10576 IFS=$as_save_IFS
10577 
10578   ;;
10579 esac
10580 fi
10581 UNAME=$ac_cv_path_UNAME
10582 if test -n "$UNAME"; then
10583   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10584 $as_echo "$UNAME" >&6; }
10585 else
10586   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10587 $as_echo "no" >&6; }
10588 fi
10589 
10590 
10591   test -n "$UNAME" && break
10592 done
10593 
10594     else
10595       # If it succeeded, then it was overridden by the user. We will use it
10596       # for the tool.
10597 
10598       # First remove it from the list of overridden variables, so we can test
10599       # for unknown variables in the end.
10600       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10601 
10602       # Check if the provided tool contains a complete path.
10603       tool_specified="$UNAME"
10604       tool_basename="${tool_specified##*/}"
10605       if test "x$tool_basename" = "x$tool_specified"; then
10606         # A command without a complete path is provided, search $PATH.
10607         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
10608 $as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
10609         # Extract the first word of "$tool_basename", so it can be a program name with args.
10610 set dummy $tool_basename; ac_word=$2
10611 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10612 $as_echo_n "checking for $ac_word... " >&6; }
10613 if ${ac_cv_path_UNAME+:} false; then :
10614   $as_echo_n "(cached) " >&6
10615 else
10616   case $UNAME in
10617   [\\/]* | ?:[\\/]*)
10618   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10619   ;;
10620   *)
10621   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10622 for as_dir in $PATH
10623 do
10624   IFS=$as_save_IFS
10625   test -z "$as_dir" && as_dir=.
10626     for ac_exec_ext in '' $ac_executable_extensions; do
10627   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10628     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10629     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10630     break 2
10631   fi
10632 done
10633   done
10634 IFS=$as_save_IFS
10635 
10636   ;;
10637 esac
10638 fi
10639 UNAME=$ac_cv_path_UNAME
10640 if test -n "$UNAME"; then
10641   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10642 $as_echo "$UNAME" >&6; }
10643 else
10644   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10645 $as_echo "no" >&6; }
10646 fi
10647 
10648 
10649         if test "x$UNAME" = x; then
10650           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10651         fi
10652       else
10653         # Otherwise we believe it is a complete path. Use it as it is.
10654         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
10655 $as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
10656         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
10657 $as_echo_n "checking for UNAME... " >&6; }
10658         if test ! -x "$tool_specified"; then
10659           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10660 $as_echo "not found" >&6; }
10661           as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
10662         fi
10663         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10664 $as_echo "$tool_specified" >&6; }
10665       fi
10666     fi
10667   fi
10668 
10669 
10670 
10671   if test "x$UNAME" = x; then
10672     as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
10673   fi
10674 
10675 
10676 
10677 
10678 
10679   # Publish this variable in the help.
10680 
10681 
10682   if test "x$UNIQ" = x; then
10683     # The variable is not set by user, try to locate tool using the code snippet
10684     for ac_prog in uniq
10685 do
10686   # Extract the first word of "$ac_prog", so it can be a program name with args.
10687 set dummy $ac_prog; ac_word=$2
10688 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10689 $as_echo_n "checking for $ac_word... " >&6; }
10690 if ${ac_cv_path_UNIQ+:} false; then :
10691   $as_echo_n "(cached) " >&6
10692 else
10693   case $UNIQ in
10694   [\\/]* | ?:[\\/]*)
10695   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10696   ;;
10697   *)
10698   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10699 for as_dir in $PATH
10700 do
10701   IFS=$as_save_IFS
10702   test -z "$as_dir" && as_dir=.
10703     for ac_exec_ext in '' $ac_executable_extensions; do
10704   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10705     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10706     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10707     break 2
10708   fi
10709 done
10710   done
10711 IFS=$as_save_IFS
10712 
10713   ;;
10714 esac
10715 fi
10716 UNIQ=$ac_cv_path_UNIQ
10717 if test -n "$UNIQ"; then
10718   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10719 $as_echo "$UNIQ" >&6; }
10720 else
10721   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10722 $as_echo "no" >&6; }
10723 fi
10724 
10725 
10726   test -n "$UNIQ" && break
10727 done
10728 
10729   else
10730     # The variable is set, but is it from the command line or the environment?
10731 
10732     # Try to remove the string !UNIQ! from our list.
10733     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
10734     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10735       # If it failed, the variable was not from the command line. Ignore it,
10736       # but warn the user (except for BASH, which is always set by the calling BASH).
10737       if test "xUNIQ" != xBASH; then
10738         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
10739 $as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
10740       fi
10741       # Try to locate tool using the code snippet
10742       for ac_prog in uniq
10743 do
10744   # Extract the first word of "$ac_prog", so it can be a program name with args.
10745 set dummy $ac_prog; ac_word=$2
10746 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10747 $as_echo_n "checking for $ac_word... " >&6; }
10748 if ${ac_cv_path_UNIQ+:} false; then :
10749   $as_echo_n "(cached) " >&6
10750 else
10751   case $UNIQ in
10752   [\\/]* | ?:[\\/]*)
10753   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10754   ;;
10755   *)
10756   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10757 for as_dir in $PATH
10758 do
10759   IFS=$as_save_IFS
10760   test -z "$as_dir" && as_dir=.
10761     for ac_exec_ext in '' $ac_executable_extensions; do
10762   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10763     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10764     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10765     break 2
10766   fi
10767 done
10768   done
10769 IFS=$as_save_IFS
10770 
10771   ;;
10772 esac
10773 fi
10774 UNIQ=$ac_cv_path_UNIQ
10775 if test -n "$UNIQ"; then
10776   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10777 $as_echo "$UNIQ" >&6; }
10778 else
10779   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10780 $as_echo "no" >&6; }
10781 fi
10782 
10783 
10784   test -n "$UNIQ" && break
10785 done
10786 
10787     else
10788       # If it succeeded, then it was overridden by the user. We will use it
10789       # for the tool.
10790 
10791       # First remove it from the list of overridden variables, so we can test
10792       # for unknown variables in the end.
10793       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10794 
10795       # Check if the provided tool contains a complete path.
10796       tool_specified="$UNIQ"
10797       tool_basename="${tool_specified##*/}"
10798       if test "x$tool_basename" = "x$tool_specified"; then
10799         # A command without a complete path is provided, search $PATH.
10800         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
10801 $as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
10802         # Extract the first word of "$tool_basename", so it can be a program name with args.
10803 set dummy $tool_basename; ac_word=$2
10804 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10805 $as_echo_n "checking for $ac_word... " >&6; }
10806 if ${ac_cv_path_UNIQ+:} false; then :
10807   $as_echo_n "(cached) " >&6
10808 else
10809   case $UNIQ in
10810   [\\/]* | ?:[\\/]*)
10811   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10812   ;;
10813   *)
10814   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10815 for as_dir in $PATH
10816 do
10817   IFS=$as_save_IFS
10818   test -z "$as_dir" && as_dir=.
10819     for ac_exec_ext in '' $ac_executable_extensions; do
10820   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10821     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10822     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10823     break 2
10824   fi
10825 done
10826   done
10827 IFS=$as_save_IFS
10828 
10829   ;;
10830 esac
10831 fi
10832 UNIQ=$ac_cv_path_UNIQ
10833 if test -n "$UNIQ"; then
10834   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10835 $as_echo "$UNIQ" >&6; }
10836 else
10837   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10838 $as_echo "no" >&6; }
10839 fi
10840 
10841 
10842         if test "x$UNIQ" = x; then
10843           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10844         fi
10845       else
10846         # Otherwise we believe it is a complete path. Use it as it is.
10847         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
10848 $as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
10849         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
10850 $as_echo_n "checking for UNIQ... " >&6; }
10851         if test ! -x "$tool_specified"; then
10852           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10853 $as_echo "not found" >&6; }
10854           as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
10855         fi
10856         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10857 $as_echo "$tool_specified" >&6; }
10858       fi
10859     fi
10860   fi
10861 
10862 
10863 
10864   if test "x$UNIQ" = x; then
10865     as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
10866   fi
10867 
10868 
10869 
10870 
10871 
10872   # Publish this variable in the help.
10873 
10874 
10875   if test "x$WC" = x; then
10876     # The variable is not set by user, try to locate tool using the code snippet
10877     for ac_prog in wc
10878 do
10879   # Extract the first word of "$ac_prog", so it can be a program name with args.
10880 set dummy $ac_prog; ac_word=$2
10881 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10882 $as_echo_n "checking for $ac_word... " >&6; }
10883 if ${ac_cv_path_WC+:} false; then :
10884   $as_echo_n "(cached) " >&6
10885 else
10886   case $WC in
10887   [\\/]* | ?:[\\/]*)
10888   ac_cv_path_WC="$WC" # Let the user override the test with a path.
10889   ;;
10890   *)
10891   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10892 for as_dir in $PATH
10893 do
10894   IFS=$as_save_IFS
10895   test -z "$as_dir" && as_dir=.
10896     for ac_exec_ext in '' $ac_executable_extensions; do
10897   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10898     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10899     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10900     break 2
10901   fi
10902 done
10903   done
10904 IFS=$as_save_IFS
10905 
10906   ;;
10907 esac
10908 fi
10909 WC=$ac_cv_path_WC
10910 if test -n "$WC"; then
10911   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10912 $as_echo "$WC" >&6; }
10913 else
10914   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10915 $as_echo "no" >&6; }
10916 fi
10917 
10918 
10919   test -n "$WC" && break
10920 done
10921 
10922   else
10923     # The variable is set, but is it from the command line or the environment?
10924 
10925     # Try to remove the string !WC! from our list.
10926     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
10927     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10928       # If it failed, the variable was not from the command line. Ignore it,
10929       # but warn the user (except for BASH, which is always set by the calling BASH).
10930       if test "xWC" != xBASH; then
10931         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
10932 $as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
10933       fi
10934       # Try to locate tool using the code snippet
10935       for ac_prog in wc
10936 do
10937   # Extract the first word of "$ac_prog", so it can be a program name with args.
10938 set dummy $ac_prog; ac_word=$2
10939 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10940 $as_echo_n "checking for $ac_word... " >&6; }
10941 if ${ac_cv_path_WC+:} false; then :
10942   $as_echo_n "(cached) " >&6
10943 else
10944   case $WC in
10945   [\\/]* | ?:[\\/]*)
10946   ac_cv_path_WC="$WC" # Let the user override the test with a path.
10947   ;;
10948   *)
10949   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10950 for as_dir in $PATH
10951 do
10952   IFS=$as_save_IFS
10953   test -z "$as_dir" && as_dir=.
10954     for ac_exec_ext in '' $ac_executable_extensions; do
10955   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10956     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10957     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10958     break 2
10959   fi
10960 done
10961   done
10962 IFS=$as_save_IFS
10963 
10964   ;;
10965 esac
10966 fi
10967 WC=$ac_cv_path_WC
10968 if test -n "$WC"; then
10969   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10970 $as_echo "$WC" >&6; }
10971 else
10972   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10973 $as_echo "no" >&6; }
10974 fi
10975 
10976 
10977   test -n "$WC" && break
10978 done
10979 
10980     else
10981       # If it succeeded, then it was overridden by the user. We will use it
10982       # for the tool.
10983 
10984       # First remove it from the list of overridden variables, so we can test
10985       # for unknown variables in the end.
10986       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10987 
10988       # Check if the provided tool contains a complete path.
10989       tool_specified="$WC"
10990       tool_basename="${tool_specified##*/}"
10991       if test "x$tool_basename" = "x$tool_specified"; then
10992         # A command without a complete path is provided, search $PATH.
10993         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
10994 $as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
10995         # Extract the first word of "$tool_basename", so it can be a program name with args.
10996 set dummy $tool_basename; ac_word=$2
10997 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10998 $as_echo_n "checking for $ac_word... " >&6; }
10999 if ${ac_cv_path_WC+:} false; then :
11000   $as_echo_n "(cached) " >&6
11001 else
11002   case $WC in
11003   [\\/]* | ?:[\\/]*)
11004   ac_cv_path_WC="$WC" # Let the user override the test with a path.
11005   ;;
11006   *)
11007   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11008 for as_dir in $PATH
11009 do
11010   IFS=$as_save_IFS
11011   test -z "$as_dir" && as_dir=.
11012     for ac_exec_ext in '' $ac_executable_extensions; do
11013   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11014     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
11015     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11016     break 2
11017   fi
11018 done
11019   done
11020 IFS=$as_save_IFS
11021 
11022   ;;
11023 esac
11024 fi
11025 WC=$ac_cv_path_WC
11026 if test -n "$WC"; then
11027   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
11028 $as_echo "$WC" >&6; }
11029 else
11030   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11031 $as_echo "no" >&6; }
11032 fi
11033 
11034 
11035         if test "x$WC" = x; then
11036           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11037         fi
11038       else
11039         # Otherwise we believe it is a complete path. Use it as it is.
11040         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
11041 $as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
11042         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
11043 $as_echo_n "checking for WC... " >&6; }
11044         if test ! -x "$tool_specified"; then
11045           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11046 $as_echo "not found" >&6; }
11047           as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
11048         fi
11049         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11050 $as_echo "$tool_specified" >&6; }
11051       fi
11052     fi
11053   fi
11054 
11055 
11056 
11057   if test "x$WC" = x; then
11058     as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
11059   fi
11060 
11061 
11062 
11063 
11064 
11065   # Publish this variable in the help.
11066 
11067 
11068   if test "x$WHICH" = x; then
11069     # The variable is not set by user, try to locate tool using the code snippet
11070     for ac_prog in which
11071 do
11072   # Extract the first word of "$ac_prog", so it can be a program name with args.
11073 set dummy $ac_prog; ac_word=$2
11074 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11075 $as_echo_n "checking for $ac_word... " >&6; }
11076 if ${ac_cv_path_WHICH+:} false; then :
11077   $as_echo_n "(cached) " >&6
11078 else
11079   case $WHICH in
11080   [\\/]* | ?:[\\/]*)
11081   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11082   ;;
11083   *)
11084   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11085 for as_dir in $PATH
11086 do
11087   IFS=$as_save_IFS
11088   test -z "$as_dir" && as_dir=.
11089     for ac_exec_ext in '' $ac_executable_extensions; do
11090   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11091     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11092     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11093     break 2
11094   fi
11095 done
11096   done
11097 IFS=$as_save_IFS
11098 
11099   ;;
11100 esac
11101 fi
11102 WHICH=$ac_cv_path_WHICH
11103 if test -n "$WHICH"; then
11104   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11105 $as_echo "$WHICH" >&6; }
11106 else
11107   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11108 $as_echo "no" >&6; }
11109 fi
11110 
11111 
11112   test -n "$WHICH" && break
11113 done
11114 
11115   else
11116     # The variable is set, but is it from the command line or the environment?
11117 
11118     # Try to remove the string !WHICH! from our list.
11119     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
11120     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11121       # If it failed, the variable was not from the command line. Ignore it,
11122       # but warn the user (except for BASH, which is always set by the calling BASH).
11123       if test "xWHICH" != xBASH; then
11124         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
11125 $as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
11126       fi
11127       # Try to locate tool using the code snippet
11128       for ac_prog in which
11129 do
11130   # Extract the first word of "$ac_prog", so it can be a program name with args.
11131 set dummy $ac_prog; ac_word=$2
11132 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11133 $as_echo_n "checking for $ac_word... " >&6; }
11134 if ${ac_cv_path_WHICH+:} false; then :
11135   $as_echo_n "(cached) " >&6
11136 else
11137   case $WHICH in
11138   [\\/]* | ?:[\\/]*)
11139   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11140   ;;
11141   *)
11142   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11143 for as_dir in $PATH
11144 do
11145   IFS=$as_save_IFS
11146   test -z "$as_dir" && as_dir=.
11147     for ac_exec_ext in '' $ac_executable_extensions; do
11148   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11149     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11150     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11151     break 2
11152   fi
11153 done
11154   done
11155 IFS=$as_save_IFS
11156 
11157   ;;
11158 esac
11159 fi
11160 WHICH=$ac_cv_path_WHICH
11161 if test -n "$WHICH"; then
11162   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11163 $as_echo "$WHICH" >&6; }
11164 else
11165   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11166 $as_echo "no" >&6; }
11167 fi
11168 
11169 
11170   test -n "$WHICH" && break
11171 done
11172 
11173     else
11174       # If it succeeded, then it was overridden by the user. We will use it
11175       # for the tool.
11176 
11177       # First remove it from the list of overridden variables, so we can test
11178       # for unknown variables in the end.
11179       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11180 
11181       # Check if the provided tool contains a complete path.
11182       tool_specified="$WHICH"
11183       tool_basename="${tool_specified##*/}"
11184       if test "x$tool_basename" = "x$tool_specified"; then
11185         # A command without a complete path is provided, search $PATH.
11186         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
11187 $as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
11188         # Extract the first word of "$tool_basename", so it can be a program name with args.
11189 set dummy $tool_basename; ac_word=$2
11190 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11191 $as_echo_n "checking for $ac_word... " >&6; }
11192 if ${ac_cv_path_WHICH+:} false; then :
11193   $as_echo_n "(cached) " >&6
11194 else
11195   case $WHICH in
11196   [\\/]* | ?:[\\/]*)
11197   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11198   ;;
11199   *)
11200   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11201 for as_dir in $PATH
11202 do
11203   IFS=$as_save_IFS
11204   test -z "$as_dir" && as_dir=.
11205     for ac_exec_ext in '' $ac_executable_extensions; do
11206   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11207     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11208     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11209     break 2
11210   fi
11211 done
11212   done
11213 IFS=$as_save_IFS
11214 
11215   ;;
11216 esac
11217 fi
11218 WHICH=$ac_cv_path_WHICH
11219 if test -n "$WHICH"; then
11220   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11221 $as_echo "$WHICH" >&6; }
11222 else
11223   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11224 $as_echo "no" >&6; }
11225 fi
11226 
11227 
11228         if test "x$WHICH" = x; then
11229           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11230         fi
11231       else
11232         # Otherwise we believe it is a complete path. Use it as it is.
11233         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
11234 $as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
11235         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
11236 $as_echo_n "checking for WHICH... " >&6; }
11237         if test ! -x "$tool_specified"; then
11238           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11239 $as_echo "not found" >&6; }
11240           as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
11241         fi
11242         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11243 $as_echo "$tool_specified" >&6; }
11244       fi
11245     fi
11246   fi
11247 
11248 
11249 
11250   if test "x$WHICH" = x; then
11251     as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
11252   fi
11253 
11254 
11255 
11256 
11257 
11258   # Publish this variable in the help.
11259 
11260 
11261   if test "x$XARGS" = x; then
11262     # The variable is not set by user, try to locate tool using the code snippet
11263     for ac_prog in xargs
11264 do
11265   # Extract the first word of "$ac_prog", so it can be a program name with args.
11266 set dummy $ac_prog; ac_word=$2
11267 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11268 $as_echo_n "checking for $ac_word... " >&6; }
11269 if ${ac_cv_path_XARGS+:} false; then :
11270   $as_echo_n "(cached) " >&6
11271 else
11272   case $XARGS in
11273   [\\/]* | ?:[\\/]*)
11274   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11275   ;;
11276   *)
11277   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11278 for as_dir in $PATH
11279 do
11280   IFS=$as_save_IFS
11281   test -z "$as_dir" && as_dir=.
11282     for ac_exec_ext in '' $ac_executable_extensions; do
11283   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11284     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11285     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11286     break 2
11287   fi
11288 done
11289   done
11290 IFS=$as_save_IFS
11291 
11292   ;;
11293 esac
11294 fi
11295 XARGS=$ac_cv_path_XARGS
11296 if test -n "$XARGS"; then
11297   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11298 $as_echo "$XARGS" >&6; }
11299 else
11300   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11301 $as_echo "no" >&6; }
11302 fi
11303 
11304 
11305   test -n "$XARGS" && break
11306 done
11307 
11308   else
11309     # The variable is set, but is it from the command line or the environment?
11310 
11311     # Try to remove the string !XARGS! from our list.
11312     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
11313     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11314       # If it failed, the variable was not from the command line. Ignore it,
11315       # but warn the user (except for BASH, which is always set by the calling BASH).
11316       if test "xXARGS" != xBASH; then
11317         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
11318 $as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
11319       fi
11320       # Try to locate tool using the code snippet
11321       for ac_prog in xargs
11322 do
11323   # Extract the first word of "$ac_prog", so it can be a program name with args.
11324 set dummy $ac_prog; ac_word=$2
11325 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11326 $as_echo_n "checking for $ac_word... " >&6; }
11327 if ${ac_cv_path_XARGS+:} false; then :
11328   $as_echo_n "(cached) " >&6
11329 else
11330   case $XARGS in
11331   [\\/]* | ?:[\\/]*)
11332   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11333   ;;
11334   *)
11335   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11336 for as_dir in $PATH
11337 do
11338   IFS=$as_save_IFS
11339   test -z "$as_dir" && as_dir=.
11340     for ac_exec_ext in '' $ac_executable_extensions; do
11341   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11342     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11343     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11344     break 2
11345   fi
11346 done
11347   done
11348 IFS=$as_save_IFS
11349 
11350   ;;
11351 esac
11352 fi
11353 XARGS=$ac_cv_path_XARGS
11354 if test -n "$XARGS"; then
11355   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11356 $as_echo "$XARGS" >&6; }
11357 else
11358   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11359 $as_echo "no" >&6; }
11360 fi
11361 
11362 
11363   test -n "$XARGS" && break
11364 done
11365 
11366     else
11367       # If it succeeded, then it was overridden by the user. We will use it
11368       # for the tool.
11369 
11370       # First remove it from the list of overridden variables, so we can test
11371       # for unknown variables in the end.
11372       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11373 
11374       # Check if the provided tool contains a complete path.
11375       tool_specified="$XARGS"
11376       tool_basename="${tool_specified##*/}"
11377       if test "x$tool_basename" = "x$tool_specified"; then
11378         # A command without a complete path is provided, search $PATH.
11379         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
11380 $as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
11381         # Extract the first word of "$tool_basename", so it can be a program name with args.
11382 set dummy $tool_basename; ac_word=$2
11383 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11384 $as_echo_n "checking for $ac_word... " >&6; }
11385 if ${ac_cv_path_XARGS+:} false; then :
11386   $as_echo_n "(cached) " >&6
11387 else
11388   case $XARGS in
11389   [\\/]* | ?:[\\/]*)
11390   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11391   ;;
11392   *)
11393   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11394 for as_dir in $PATH
11395 do
11396   IFS=$as_save_IFS
11397   test -z "$as_dir" && as_dir=.
11398     for ac_exec_ext in '' $ac_executable_extensions; do
11399   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11400     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11401     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11402     break 2
11403   fi
11404 done
11405   done
11406 IFS=$as_save_IFS
11407 
11408   ;;
11409 esac
11410 fi
11411 XARGS=$ac_cv_path_XARGS
11412 if test -n "$XARGS"; then
11413   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11414 $as_echo "$XARGS" >&6; }
11415 else
11416   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11417 $as_echo "no" >&6; }
11418 fi
11419 
11420 
11421         if test "x$XARGS" = x; then
11422           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11423         fi
11424       else
11425         # Otherwise we believe it is a complete path. Use it as it is.
11426         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
11427 $as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
11428         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
11429 $as_echo_n "checking for XARGS... " >&6; }
11430         if test ! -x "$tool_specified"; then
11431           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11432 $as_echo "not found" >&6; }
11433           as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
11434         fi
11435         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11436 $as_echo "$tool_specified" >&6; }
11437       fi
11438     fi
11439   fi
11440 
11441 
11442 
11443   if test "x$XARGS" = x; then
11444     as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
11445   fi
11446 
11447 
11448 
11449   # Then required tools that require some special treatment.
11450 
11451 
11452   # Publish this variable in the help.
11453 
11454 
11455   if test "x$AWK" = x; then
11456     # The variable is not set by user, try to locate tool using the code snippet
11457     for ac_prog in gawk mawk nawk awk
11458 do
11459   # Extract the first word of "$ac_prog", so it can be a program name with args.
11460 set dummy $ac_prog; ac_word=$2
11461 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11462 $as_echo_n "checking for $ac_word... " >&6; }
11463 if ${ac_cv_prog_AWK+:} false; then :
11464   $as_echo_n "(cached) " >&6
11465 else
11466   if test -n "$AWK"; then
11467   ac_cv_prog_AWK="$AWK" # Let the user override the test.
11468 else
11469 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11470 for as_dir in $PATH
11471 do
11472   IFS=$as_save_IFS
11473   test -z "$as_dir" && as_dir=.
11474     for ac_exec_ext in '' $ac_executable_extensions; do
11475   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11476     ac_cv_prog_AWK="$ac_prog"
11477     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11478     break 2
11479   fi
11480 done
11481   done
11482 IFS=$as_save_IFS
11483 
11484 fi
11485 fi
11486 AWK=$ac_cv_prog_AWK
11487 if test -n "$AWK"; then
11488   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11489 $as_echo "$AWK" >&6; }
11490 else
11491   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11492 $as_echo "no" >&6; }
11493 fi
11494 
11495 
11496   test -n "$AWK" && break
11497 done
11498 
11499   else
11500     # The variable is set, but is it from the command line or the environment?
11501 
11502     # Try to remove the string !AWK! from our list.
11503     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
11504     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11505       # If it failed, the variable was not from the command line. Ignore it,
11506       # but warn the user (except for BASH, which is always set by the calling BASH).
11507       if test "xAWK" != xBASH; then
11508         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
11509 $as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
11510       fi
11511       # Try to locate tool using the code snippet
11512       for ac_prog in gawk mawk nawk awk
11513 do
11514   # Extract the first word of "$ac_prog", so it can be a program name with args.
11515 set dummy $ac_prog; ac_word=$2
11516 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11517 $as_echo_n "checking for $ac_word... " >&6; }
11518 if ${ac_cv_prog_AWK+:} false; then :
11519   $as_echo_n "(cached) " >&6
11520 else
11521   if test -n "$AWK"; then
11522   ac_cv_prog_AWK="$AWK" # Let the user override the test.
11523 else
11524 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11525 for as_dir in $PATH
11526 do
11527   IFS=$as_save_IFS
11528   test -z "$as_dir" && as_dir=.
11529     for ac_exec_ext in '' $ac_executable_extensions; do
11530   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11531     ac_cv_prog_AWK="$ac_prog"
11532     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11533     break 2
11534   fi
11535 done
11536   done
11537 IFS=$as_save_IFS
11538 
11539 fi
11540 fi
11541 AWK=$ac_cv_prog_AWK
11542 if test -n "$AWK"; then
11543   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11544 $as_echo "$AWK" >&6; }
11545 else
11546   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11547 $as_echo "no" >&6; }
11548 fi
11549 
11550 
11551   test -n "$AWK" && break
11552 done
11553 
11554     else
11555       # If it succeeded, then it was overridden by the user. We will use it
11556       # for the tool.
11557 
11558       # First remove it from the list of overridden variables, so we can test
11559       # for unknown variables in the end.
11560       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11561 
11562       # Check if the provided tool contains a complete path.
11563       tool_specified="$AWK"
11564       tool_basename="${tool_specified##*/}"
11565       if test "x$tool_basename" = "x$tool_specified"; then
11566         # A command without a complete path is provided, search $PATH.
11567         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
11568 $as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
11569         # Extract the first word of "$tool_basename", so it can be a program name with args.
11570 set dummy $tool_basename; ac_word=$2
11571 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11572 $as_echo_n "checking for $ac_word... " >&6; }
11573 if ${ac_cv_path_AWK+:} false; then :
11574   $as_echo_n "(cached) " >&6
11575 else
11576   case $AWK in
11577   [\\/]* | ?:[\\/]*)
11578   ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
11579   ;;
11580   *)
11581   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11582 for as_dir in $PATH
11583 do
11584   IFS=$as_save_IFS
11585   test -z "$as_dir" && as_dir=.
11586     for ac_exec_ext in '' $ac_executable_extensions; do
11587   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11588     ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
11589     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11590     break 2
11591   fi
11592 done
11593   done
11594 IFS=$as_save_IFS
11595 
11596   ;;
11597 esac
11598 fi
11599 AWK=$ac_cv_path_AWK
11600 if test -n "$AWK"; then
11601   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11602 $as_echo "$AWK" >&6; }
11603 else
11604   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11605 $as_echo "no" >&6; }
11606 fi
11607 
11608 
11609         if test "x$AWK" = x; then
11610           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11611         fi
11612       else
11613         # Otherwise we believe it is a complete path. Use it as it is.
11614         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
11615 $as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
11616         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
11617 $as_echo_n "checking for AWK... " >&6; }
11618         if test ! -x "$tool_specified"; then
11619           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11620 $as_echo "not found" >&6; }
11621           as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
11622         fi
11623         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11624 $as_echo "$tool_specified" >&6; }
11625       fi
11626     fi
11627   fi
11628 
11629 
11630   if test "x$AWK" = x; then
11631     as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
11632   fi
11633 
11634 
11635 
11636 
11637   # Publish this variable in the help.
11638 
11639 
11640   if test "x$GREP" = x; then
11641     # The variable is not set by user, try to locate tool using the code snippet
11642     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11643 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11644 if ${ac_cv_path_GREP+:} false; then :
11645   $as_echo_n "(cached) " >&6
11646 else
11647   if test -z "$GREP"; then
11648   ac_path_GREP_found=false
11649   # Loop through the user's path and test for each of PROGNAME-LIST
11650   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11651 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11652 do
11653   IFS=$as_save_IFS
11654   test -z "$as_dir" && as_dir=.
11655     for ac_prog in grep ggrep; do
11656     for ac_exec_ext in '' $ac_executable_extensions; do
11657       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11658       as_fn_executable_p "$ac_path_GREP" || continue
11659 # Check for GNU ac_path_GREP and select it if it is found.
11660   # Check for GNU $ac_path_GREP
11661 case `"$ac_path_GREP" --version 2>&1` in
11662 *GNU*)
11663   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11664 *)
11665   ac_count=0
11666   $as_echo_n 0123456789 >"conftest.in"
11667   while :
11668   do
11669     cat "conftest.in" "conftest.in" >"conftest.tmp"
11670     mv "conftest.tmp" "conftest.in"
11671     cp "conftest.in" "conftest.nl"
11672     $as_echo 'GREP' >> "conftest.nl"
11673     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11674     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11675     as_fn_arith $ac_count + 1 && ac_count=$as_val
11676     if test $ac_count -gt ${ac_path_GREP_max-0}; then
11677       # Best one so far, save it but keep looking for a better one
11678       ac_cv_path_GREP="$ac_path_GREP"
11679       ac_path_GREP_max=$ac_count
11680     fi
11681     # 10*(2^10) chars as input seems more than enough
11682     test $ac_count -gt 10 && break
11683   done
11684   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11685 esac
11686 
11687       $ac_path_GREP_found && break 3
11688     done
11689   done
11690   done
11691 IFS=$as_save_IFS
11692   if test -z "$ac_cv_path_GREP"; then
11693     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11694   fi
11695 else
11696   ac_cv_path_GREP=$GREP
11697 fi
11698 
11699 fi
11700 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11701 $as_echo "$ac_cv_path_GREP" >&6; }
11702  GREP="$ac_cv_path_GREP"
11703 
11704 
11705   else
11706     # The variable is set, but is it from the command line or the environment?
11707 
11708     # Try to remove the string !GREP! from our list.
11709     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
11710     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11711       # If it failed, the variable was not from the command line. Ignore it,
11712       # but warn the user (except for BASH, which is always set by the calling BASH).
11713       if test "xGREP" != xBASH; then
11714         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
11715 $as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
11716       fi
11717       # Try to locate tool using the code snippet
11718       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11719 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11720 if ${ac_cv_path_GREP+:} false; then :
11721   $as_echo_n "(cached) " >&6
11722 else
11723   if test -z "$GREP"; then
11724   ac_path_GREP_found=false
11725   # Loop through the user's path and test for each of PROGNAME-LIST
11726   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11727 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11728 do
11729   IFS=$as_save_IFS
11730   test -z "$as_dir" && as_dir=.
11731     for ac_prog in grep ggrep; do
11732     for ac_exec_ext in '' $ac_executable_extensions; do
11733       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11734       as_fn_executable_p "$ac_path_GREP" || continue
11735 # Check for GNU ac_path_GREP and select it if it is found.
11736   # Check for GNU $ac_path_GREP
11737 case `"$ac_path_GREP" --version 2>&1` in
11738 *GNU*)
11739   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11740 *)
11741   ac_count=0
11742   $as_echo_n 0123456789 >"conftest.in"
11743   while :
11744   do
11745     cat "conftest.in" "conftest.in" >"conftest.tmp"
11746     mv "conftest.tmp" "conftest.in"
11747     cp "conftest.in" "conftest.nl"
11748     $as_echo 'GREP' >> "conftest.nl"
11749     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11750     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11751     as_fn_arith $ac_count + 1 && ac_count=$as_val
11752     if test $ac_count -gt ${ac_path_GREP_max-0}; then
11753       # Best one so far, save it but keep looking for a better one
11754       ac_cv_path_GREP="$ac_path_GREP"
11755       ac_path_GREP_max=$ac_count
11756     fi
11757     # 10*(2^10) chars as input seems more than enough
11758     test $ac_count -gt 10 && break
11759   done
11760   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11761 esac
11762 
11763       $ac_path_GREP_found && break 3
11764     done
11765   done
11766   done
11767 IFS=$as_save_IFS
11768   if test -z "$ac_cv_path_GREP"; then
11769     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11770   fi
11771 else
11772   ac_cv_path_GREP=$GREP
11773 fi
11774 
11775 fi
11776 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11777 $as_echo "$ac_cv_path_GREP" >&6; }
11778  GREP="$ac_cv_path_GREP"
11779 
11780 
11781     else
11782       # If it succeeded, then it was overridden by the user. We will use it
11783       # for the tool.
11784 
11785       # First remove it from the list of overridden variables, so we can test
11786       # for unknown variables in the end.
11787       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11788 
11789       # Check if the provided tool contains a complete path.
11790       tool_specified="$GREP"
11791       tool_basename="${tool_specified##*/}"
11792       if test "x$tool_basename" = "x$tool_specified"; then
11793         # A command without a complete path is provided, search $PATH.
11794         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
11795 $as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
11796         # Extract the first word of "$tool_basename", so it can be a program name with args.
11797 set dummy $tool_basename; ac_word=$2
11798 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11799 $as_echo_n "checking for $ac_word... " >&6; }
11800 if ${ac_cv_path_GREP+:} false; then :
11801   $as_echo_n "(cached) " >&6
11802 else
11803   case $GREP in
11804   [\\/]* | ?:[\\/]*)
11805   ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
11806   ;;
11807   *)
11808   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11809 for as_dir in $PATH
11810 do
11811   IFS=$as_save_IFS
11812   test -z "$as_dir" && as_dir=.
11813     for ac_exec_ext in '' $ac_executable_extensions; do
11814   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11815     ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
11816     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11817     break 2
11818   fi
11819 done
11820   done
11821 IFS=$as_save_IFS
11822 
11823   ;;
11824 esac
11825 fi
11826 GREP=$ac_cv_path_GREP
11827 if test -n "$GREP"; then
11828   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
11829 $as_echo "$GREP" >&6; }
11830 else
11831   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11832 $as_echo "no" >&6; }
11833 fi
11834 
11835 
11836         if test "x$GREP" = x; then
11837           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11838         fi
11839       else
11840         # Otherwise we believe it is a complete path. Use it as it is.
11841         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
11842 $as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
11843         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
11844 $as_echo_n "checking for GREP... " >&6; }
11845         if test ! -x "$tool_specified"; then
11846           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11847 $as_echo "not found" >&6; }
11848           as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
11849         fi
11850         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11851 $as_echo "$tool_specified" >&6; }
11852       fi
11853     fi
11854   fi
11855 
11856 
11857   if test "x$GREP" = x; then
11858     as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
11859   fi
11860 
11861 
11862 
11863 
11864   # Publish this variable in the help.
11865 
11866 
11867   if test "x$EGREP" = x; then
11868     # The variable is not set by user, try to locate tool using the code snippet
11869     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11870 $as_echo_n "checking for egrep... " >&6; }
11871 if ${ac_cv_path_EGREP+:} false; then :
11872   $as_echo_n "(cached) " >&6
11873 else
11874   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11875    then ac_cv_path_EGREP="$GREP -E"
11876    else
11877      if test -z "$EGREP"; then
11878   ac_path_EGREP_found=false
11879   # Loop through the user's path and test for each of PROGNAME-LIST
11880   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11881 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11882 do
11883   IFS=$as_save_IFS
11884   test -z "$as_dir" && as_dir=.
11885     for ac_prog in egrep; do
11886     for ac_exec_ext in '' $ac_executable_extensions; do
11887       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11888       as_fn_executable_p "$ac_path_EGREP" || continue
11889 # Check for GNU ac_path_EGREP and select it if it is found.
11890   # Check for GNU $ac_path_EGREP
11891 case `"$ac_path_EGREP" --version 2>&1` in
11892 *GNU*)
11893   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11894 *)
11895   ac_count=0
11896   $as_echo_n 0123456789 >"conftest.in"
11897   while :
11898   do
11899     cat "conftest.in" "conftest.in" >"conftest.tmp"
11900     mv "conftest.tmp" "conftest.in"
11901     cp "conftest.in" "conftest.nl"
11902     $as_echo 'EGREP' >> "conftest.nl"
11903     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11904     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11905     as_fn_arith $ac_count + 1 && ac_count=$as_val
11906     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11907       # Best one so far, save it but keep looking for a better one
11908       ac_cv_path_EGREP="$ac_path_EGREP"
11909       ac_path_EGREP_max=$ac_count
11910     fi
11911     # 10*(2^10) chars as input seems more than enough
11912     test $ac_count -gt 10 && break
11913   done
11914   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11915 esac
11916 
11917       $ac_path_EGREP_found && break 3
11918     done
11919   done
11920   done
11921 IFS=$as_save_IFS
11922   if test -z "$ac_cv_path_EGREP"; then
11923     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11924   fi
11925 else
11926   ac_cv_path_EGREP=$EGREP
11927 fi
11928 
11929    fi
11930 fi
11931 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11932 $as_echo "$ac_cv_path_EGREP" >&6; }
11933  EGREP="$ac_cv_path_EGREP"
11934 
11935 
11936   else
11937     # The variable is set, but is it from the command line or the environment?
11938 
11939     # Try to remove the string !EGREP! from our list.
11940     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
11941     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11942       # If it failed, the variable was not from the command line. Ignore it,
11943       # but warn the user (except for BASH, which is always set by the calling BASH).
11944       if test "xEGREP" != xBASH; then
11945         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
11946 $as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
11947       fi
11948       # Try to locate tool using the code snippet
11949       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11950 $as_echo_n "checking for egrep... " >&6; }
11951 if ${ac_cv_path_EGREP+:} false; then :
11952   $as_echo_n "(cached) " >&6
11953 else
11954   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11955    then ac_cv_path_EGREP="$GREP -E"
11956    else
11957      if test -z "$EGREP"; then
11958   ac_path_EGREP_found=false
11959   # Loop through the user's path and test for each of PROGNAME-LIST
11960   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11961 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11962 do
11963   IFS=$as_save_IFS
11964   test -z "$as_dir" && as_dir=.
11965     for ac_prog in egrep; do
11966     for ac_exec_ext in '' $ac_executable_extensions; do
11967       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11968       as_fn_executable_p "$ac_path_EGREP" || continue
11969 # Check for GNU ac_path_EGREP and select it if it is found.
11970   # Check for GNU $ac_path_EGREP
11971 case `"$ac_path_EGREP" --version 2>&1` in
11972 *GNU*)
11973   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11974 *)
11975   ac_count=0
11976   $as_echo_n 0123456789 >"conftest.in"
11977   while :
11978   do
11979     cat "conftest.in" "conftest.in" >"conftest.tmp"
11980     mv "conftest.tmp" "conftest.in"
11981     cp "conftest.in" "conftest.nl"
11982     $as_echo 'EGREP' >> "conftest.nl"
11983     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11984     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11985     as_fn_arith $ac_count + 1 && ac_count=$as_val
11986     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11987       # Best one so far, save it but keep looking for a better one
11988       ac_cv_path_EGREP="$ac_path_EGREP"
11989       ac_path_EGREP_max=$ac_count
11990     fi
11991     # 10*(2^10) chars as input seems more than enough
11992     test $ac_count -gt 10 && break
11993   done
11994   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11995 esac
11996 
11997       $ac_path_EGREP_found && break 3
11998     done
11999   done
12000   done
12001 IFS=$as_save_IFS
12002   if test -z "$ac_cv_path_EGREP"; then
12003     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12004   fi
12005 else
12006   ac_cv_path_EGREP=$EGREP
12007 fi
12008 
12009    fi
12010 fi
12011 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
12012 $as_echo "$ac_cv_path_EGREP" >&6; }
12013  EGREP="$ac_cv_path_EGREP"
12014 
12015 
12016     else
12017       # If it succeeded, then it was overridden by the user. We will use it
12018       # for the tool.
12019 
12020       # First remove it from the list of overridden variables, so we can test
12021       # for unknown variables in the end.
12022       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12023 
12024       # Check if the provided tool contains a complete path.
12025       tool_specified="$EGREP"
12026       tool_basename="${tool_specified##*/}"
12027       if test "x$tool_basename" = "x$tool_specified"; then
12028         # A command without a complete path is provided, search $PATH.
12029         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
12030 $as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
12031         # Extract the first word of "$tool_basename", so it can be a program name with args.
12032 set dummy $tool_basename; ac_word=$2
12033 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12034 $as_echo_n "checking for $ac_word... " >&6; }
12035 if ${ac_cv_path_EGREP+:} false; then :
12036   $as_echo_n "(cached) " >&6
12037 else
12038   case $EGREP in
12039   [\\/]* | ?:[\\/]*)
12040   ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
12041   ;;
12042   *)
12043   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12044 for as_dir in $PATH
12045 do
12046   IFS=$as_save_IFS
12047   test -z "$as_dir" && as_dir=.
12048     for ac_exec_ext in '' $ac_executable_extensions; do
12049   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12050     ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
12051     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12052     break 2
12053   fi
12054 done
12055   done
12056 IFS=$as_save_IFS
12057 
12058   ;;
12059 esac
12060 fi
12061 EGREP=$ac_cv_path_EGREP
12062 if test -n "$EGREP"; then
12063   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
12064 $as_echo "$EGREP" >&6; }
12065 else
12066   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12067 $as_echo "no" >&6; }
12068 fi
12069 
12070 
12071         if test "x$EGREP" = x; then
12072           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12073         fi
12074       else
12075         # Otherwise we believe it is a complete path. Use it as it is.
12076         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
12077 $as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
12078         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
12079 $as_echo_n "checking for EGREP... " >&6; }
12080         if test ! -x "$tool_specified"; then
12081           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12082 $as_echo "not found" >&6; }
12083           as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12084         fi
12085         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12086 $as_echo "$tool_specified" >&6; }
12087       fi
12088     fi
12089   fi
12090 
12091 
12092   if test "x$EGREP" = x; then
12093     as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
12094   fi
12095 
12096 
12097 
12098 
12099   # Publish this variable in the help.
12100 
12101 
12102   if test "x$FGREP" = x; then
12103     # The variable is not set by user, try to locate tool using the code snippet
12104     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12105 $as_echo_n "checking for fgrep... " >&6; }
12106 if ${ac_cv_path_FGREP+:} false; then :
12107   $as_echo_n "(cached) " >&6
12108 else
12109   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12110    then ac_cv_path_FGREP="$GREP -F"
12111    else
12112      if test -z "$FGREP"; then
12113   ac_path_FGREP_found=false
12114   # Loop through the user's path and test for each of PROGNAME-LIST
12115   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12116 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12117 do
12118   IFS=$as_save_IFS
12119   test -z "$as_dir" && as_dir=.
12120     for ac_prog in fgrep; do
12121     for ac_exec_ext in '' $ac_executable_extensions; do
12122       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12123       as_fn_executable_p "$ac_path_FGREP" || continue
12124 # Check for GNU ac_path_FGREP and select it if it is found.
12125   # Check for GNU $ac_path_FGREP
12126 case `"$ac_path_FGREP" --version 2>&1` in
12127 *GNU*)
12128   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12129 *)
12130   ac_count=0
12131   $as_echo_n 0123456789 >"conftest.in"
12132   while :
12133   do
12134     cat "conftest.in" "conftest.in" >"conftest.tmp"
12135     mv "conftest.tmp" "conftest.in"
12136     cp "conftest.in" "conftest.nl"
12137     $as_echo 'FGREP' >> "conftest.nl"
12138     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12139     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12140     as_fn_arith $ac_count + 1 && ac_count=$as_val
12141     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12142       # Best one so far, save it but keep looking for a better one
12143       ac_cv_path_FGREP="$ac_path_FGREP"
12144       ac_path_FGREP_max=$ac_count
12145     fi
12146     # 10*(2^10) chars as input seems more than enough
12147     test $ac_count -gt 10 && break
12148   done
12149   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12150 esac
12151 
12152       $ac_path_FGREP_found && break 3
12153     done
12154   done
12155   done
12156 IFS=$as_save_IFS
12157   if test -z "$ac_cv_path_FGREP"; then
12158     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12159   fi
12160 else
12161   ac_cv_path_FGREP=$FGREP
12162 fi
12163 
12164    fi
12165 fi
12166 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12167 $as_echo "$ac_cv_path_FGREP" >&6; }
12168  FGREP="$ac_cv_path_FGREP"
12169 
12170 
12171   else
12172     # The variable is set, but is it from the command line or the environment?
12173 
12174     # Try to remove the string !FGREP! from our list.
12175     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
12176     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12177       # If it failed, the variable was not from the command line. Ignore it,
12178       # but warn the user (except for BASH, which is always set by the calling BASH).
12179       if test "xFGREP" != xBASH; then
12180         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
12181 $as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
12182       fi
12183       # Try to locate tool using the code snippet
12184       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12185 $as_echo_n "checking for fgrep... " >&6; }
12186 if ${ac_cv_path_FGREP+:} false; then :
12187   $as_echo_n "(cached) " >&6
12188 else
12189   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12190    then ac_cv_path_FGREP="$GREP -F"
12191    else
12192      if test -z "$FGREP"; then
12193   ac_path_FGREP_found=false
12194   # Loop through the user's path and test for each of PROGNAME-LIST
12195   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12196 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12197 do
12198   IFS=$as_save_IFS
12199   test -z "$as_dir" && as_dir=.
12200     for ac_prog in fgrep; do
12201     for ac_exec_ext in '' $ac_executable_extensions; do
12202       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12203       as_fn_executable_p "$ac_path_FGREP" || continue
12204 # Check for GNU ac_path_FGREP and select it if it is found.
12205   # Check for GNU $ac_path_FGREP
12206 case `"$ac_path_FGREP" --version 2>&1` in
12207 *GNU*)
12208   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12209 *)
12210   ac_count=0
12211   $as_echo_n 0123456789 >"conftest.in"
12212   while :
12213   do
12214     cat "conftest.in" "conftest.in" >"conftest.tmp"
12215     mv "conftest.tmp" "conftest.in"
12216     cp "conftest.in" "conftest.nl"
12217     $as_echo 'FGREP' >> "conftest.nl"
12218     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12219     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12220     as_fn_arith $ac_count + 1 && ac_count=$as_val
12221     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12222       # Best one so far, save it but keep looking for a better one
12223       ac_cv_path_FGREP="$ac_path_FGREP"
12224       ac_path_FGREP_max=$ac_count
12225     fi
12226     # 10*(2^10) chars as input seems more than enough
12227     test $ac_count -gt 10 && break
12228   done
12229   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12230 esac
12231 
12232       $ac_path_FGREP_found && break 3
12233     done
12234   done
12235   done
12236 IFS=$as_save_IFS
12237   if test -z "$ac_cv_path_FGREP"; then
12238     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12239   fi
12240 else
12241   ac_cv_path_FGREP=$FGREP
12242 fi
12243 
12244    fi
12245 fi
12246 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12247 $as_echo "$ac_cv_path_FGREP" >&6; }
12248  FGREP="$ac_cv_path_FGREP"
12249 
12250 
12251     else
12252       # If it succeeded, then it was overridden by the user. We will use it
12253       # for the tool.
12254 
12255       # First remove it from the list of overridden variables, so we can test
12256       # for unknown variables in the end.
12257       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12258 
12259       # Check if the provided tool contains a complete path.
12260       tool_specified="$FGREP"
12261       tool_basename="${tool_specified##*/}"
12262       if test "x$tool_basename" = "x$tool_specified"; then
12263         # A command without a complete path is provided, search $PATH.
12264         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
12265 $as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
12266         # Extract the first word of "$tool_basename", so it can be a program name with args.
12267 set dummy $tool_basename; ac_word=$2
12268 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12269 $as_echo_n "checking for $ac_word... " >&6; }
12270 if ${ac_cv_path_FGREP+:} false; then :
12271   $as_echo_n "(cached) " >&6
12272 else
12273   case $FGREP in
12274   [\\/]* | ?:[\\/]*)
12275   ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
12276   ;;
12277   *)
12278   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12279 for as_dir in $PATH
12280 do
12281   IFS=$as_save_IFS
12282   test -z "$as_dir" && as_dir=.
12283     for ac_exec_ext in '' $ac_executable_extensions; do
12284   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12285     ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
12286     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12287     break 2
12288   fi
12289 done
12290   done
12291 IFS=$as_save_IFS
12292 
12293   ;;
12294 esac
12295 fi
12296 FGREP=$ac_cv_path_FGREP
12297 if test -n "$FGREP"; then
12298   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
12299 $as_echo "$FGREP" >&6; }
12300 else
12301   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12302 $as_echo "no" >&6; }
12303 fi
12304 
12305 
12306         if test "x$FGREP" = x; then
12307           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12308         fi
12309       else
12310         # Otherwise we believe it is a complete path. Use it as it is.
12311         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
12312 $as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
12313         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
12314 $as_echo_n "checking for FGREP... " >&6; }
12315         if test ! -x "$tool_specified"; then
12316           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12317 $as_echo "not found" >&6; }
12318           as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12319         fi
12320         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12321 $as_echo "$tool_specified" >&6; }
12322       fi
12323     fi
12324   fi
12325 
12326 
12327   if test "x$FGREP" = x; then
12328     as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
12329   fi
12330 
12331 
12332 
12333 
12334   # Publish this variable in the help.
12335 
12336 
12337   if test "x$SED" = x; then
12338     # The variable is not set by user, try to locate tool using the code snippet
12339     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12340 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12341 if ${ac_cv_path_SED+:} false; then :
12342   $as_echo_n "(cached) " >&6
12343 else
12344             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12345      for ac_i in 1 2 3 4 5 6 7; do
12346        ac_script="$ac_script$as_nl$ac_script"
12347      done
12348      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12349      { ac_script=; unset ac_script;}
12350      if test -z "$SED"; then
12351   ac_path_SED_found=false
12352   # Loop through the user's path and test for each of PROGNAME-LIST
12353   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12354 for as_dir in $PATH
12355 do
12356   IFS=$as_save_IFS
12357   test -z "$as_dir" && as_dir=.
12358     for ac_prog in sed gsed; do
12359     for ac_exec_ext in '' $ac_executable_extensions; do
12360       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12361       as_fn_executable_p "$ac_path_SED" || continue
12362 # Check for GNU ac_path_SED and select it if it is found.
12363   # Check for GNU $ac_path_SED
12364 case `"$ac_path_SED" --version 2>&1` in
12365 *GNU*)
12366   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12367 *)
12368   ac_count=0
12369   $as_echo_n 0123456789 >"conftest.in"
12370   while :
12371   do
12372     cat "conftest.in" "conftest.in" >"conftest.tmp"
12373     mv "conftest.tmp" "conftest.in"
12374     cp "conftest.in" "conftest.nl"
12375     $as_echo '' >> "conftest.nl"
12376     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12377     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12378     as_fn_arith $ac_count + 1 && ac_count=$as_val
12379     if test $ac_count -gt ${ac_path_SED_max-0}; then
12380       # Best one so far, save it but keep looking for a better one
12381       ac_cv_path_SED="$ac_path_SED"
12382       ac_path_SED_max=$ac_count
12383     fi
12384     # 10*(2^10) chars as input seems more than enough
12385     test $ac_count -gt 10 && break
12386   done
12387   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12388 esac
12389 
12390       $ac_path_SED_found && break 3
12391     done
12392   done
12393   done
12394 IFS=$as_save_IFS
12395   if test -z "$ac_cv_path_SED"; then
12396     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12397   fi
12398 else
12399   ac_cv_path_SED=$SED
12400 fi
12401 
12402 fi
12403 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12404 $as_echo "$ac_cv_path_SED" >&6; }
12405  SED="$ac_cv_path_SED"
12406   rm -f conftest.sed
12407 
12408   else
12409     # The variable is set, but is it from the command line or the environment?
12410 
12411     # Try to remove the string !SED! from our list.
12412     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
12413     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12414       # If it failed, the variable was not from the command line. Ignore it,
12415       # but warn the user (except for BASH, which is always set by the calling BASH).
12416       if test "xSED" != xBASH; then
12417         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
12418 $as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
12419       fi
12420       # Try to locate tool using the code snippet
12421       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12422 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12423 if ${ac_cv_path_SED+:} false; then :
12424   $as_echo_n "(cached) " >&6
12425 else
12426             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12427      for ac_i in 1 2 3 4 5 6 7; do
12428        ac_script="$ac_script$as_nl$ac_script"
12429      done
12430      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12431      { ac_script=; unset ac_script;}
12432      if test -z "$SED"; then
12433   ac_path_SED_found=false
12434   # Loop through the user's path and test for each of PROGNAME-LIST
12435   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12436 for as_dir in $PATH
12437 do
12438   IFS=$as_save_IFS
12439   test -z "$as_dir" && as_dir=.
12440     for ac_prog in sed gsed; do
12441     for ac_exec_ext in '' $ac_executable_extensions; do
12442       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12443       as_fn_executable_p "$ac_path_SED" || continue
12444 # Check for GNU ac_path_SED and select it if it is found.
12445   # Check for GNU $ac_path_SED
12446 case `"$ac_path_SED" --version 2>&1` in
12447 *GNU*)
12448   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12449 *)
12450   ac_count=0
12451   $as_echo_n 0123456789 >"conftest.in"
12452   while :
12453   do
12454     cat "conftest.in" "conftest.in" >"conftest.tmp"
12455     mv "conftest.tmp" "conftest.in"
12456     cp "conftest.in" "conftest.nl"
12457     $as_echo '' >> "conftest.nl"
12458     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12459     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12460     as_fn_arith $ac_count + 1 && ac_count=$as_val
12461     if test $ac_count -gt ${ac_path_SED_max-0}; then
12462       # Best one so far, save it but keep looking for a better one
12463       ac_cv_path_SED="$ac_path_SED"
12464       ac_path_SED_max=$ac_count
12465     fi
12466     # 10*(2^10) chars as input seems more than enough
12467     test $ac_count -gt 10 && break
12468   done
12469   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12470 esac
12471 
12472       $ac_path_SED_found && break 3
12473     done
12474   done
12475   done
12476 IFS=$as_save_IFS
12477   if test -z "$ac_cv_path_SED"; then
12478     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12479   fi
12480 else
12481   ac_cv_path_SED=$SED
12482 fi
12483 
12484 fi
12485 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12486 $as_echo "$ac_cv_path_SED" >&6; }
12487  SED="$ac_cv_path_SED"
12488   rm -f conftest.sed
12489 
12490     else
12491       # If it succeeded, then it was overridden by the user. We will use it
12492       # for the tool.
12493 
12494       # First remove it from the list of overridden variables, so we can test
12495       # for unknown variables in the end.
12496       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12497 
12498       # Check if the provided tool contains a complete path.
12499       tool_specified="$SED"
12500       tool_basename="${tool_specified##*/}"
12501       if test "x$tool_basename" = "x$tool_specified"; then
12502         # A command without a complete path is provided, search $PATH.
12503         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
12504 $as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
12505         # Extract the first word of "$tool_basename", so it can be a program name with args.
12506 set dummy $tool_basename; ac_word=$2
12507 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12508 $as_echo_n "checking for $ac_word... " >&6; }
12509 if ${ac_cv_path_SED+:} false; then :
12510   $as_echo_n "(cached) " >&6
12511 else
12512   case $SED in
12513   [\\/]* | ?:[\\/]*)
12514   ac_cv_path_SED="$SED" # Let the user override the test with a path.
12515   ;;
12516   *)
12517   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12518 for as_dir in $PATH
12519 do
12520   IFS=$as_save_IFS
12521   test -z "$as_dir" && as_dir=.
12522     for ac_exec_ext in '' $ac_executable_extensions; do
12523   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12524     ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
12525     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12526     break 2
12527   fi
12528 done
12529   done
12530 IFS=$as_save_IFS
12531 
12532   ;;
12533 esac
12534 fi
12535 SED=$ac_cv_path_SED
12536 if test -n "$SED"; then
12537   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
12538 $as_echo "$SED" >&6; }
12539 else
12540   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12541 $as_echo "no" >&6; }
12542 fi
12543 
12544 
12545         if test "x$SED" = x; then
12546           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12547         fi
12548       else
12549         # Otherwise we believe it is a complete path. Use it as it is.
12550         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
12551 $as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
12552         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
12553 $as_echo_n "checking for SED... " >&6; }
12554         if test ! -x "$tool_specified"; then
12555           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12556 $as_echo "not found" >&6; }
12557           as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
12558         fi
12559         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12560 $as_echo "$tool_specified" >&6; }
12561       fi
12562     fi
12563   fi
12564 
12565 
12566   if test "x$SED" = x; then
12567     as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
12568   fi
12569 
12570 
12571 
12572   # Always force rm.
12573   RM="$RM -f"
12574 
12575   # pwd behaves differently on various platforms and some don't support the -L flag.
12576   # Always use the bash builtin pwd to get uniform behavior.
12577   THEPWDCMD=pwd
12578 
12579   # These are not required on all platforms
12580 
12581 
12582   # Publish this variable in the help.
12583 
12584 
12585   if test "x$CYGPATH" = x; then
12586     # The variable is not set by user, try to locate tool using the code snippet
12587     for ac_prog in cygpath
12588 do
12589   # Extract the first word of "$ac_prog", so it can be a program name with args.
12590 set dummy $ac_prog; ac_word=$2
12591 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12592 $as_echo_n "checking for $ac_word... " >&6; }
12593 if ${ac_cv_path_CYGPATH+:} false; then :
12594   $as_echo_n "(cached) " >&6
12595 else
12596   case $CYGPATH in
12597   [\\/]* | ?:[\\/]*)
12598   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12599   ;;
12600   *)
12601   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12602 for as_dir in $PATH
12603 do
12604   IFS=$as_save_IFS
12605   test -z "$as_dir" && as_dir=.
12606     for ac_exec_ext in '' $ac_executable_extensions; do
12607   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12608     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12609     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12610     break 2
12611   fi
12612 done
12613   done
12614 IFS=$as_save_IFS
12615 
12616   ;;
12617 esac
12618 fi
12619 CYGPATH=$ac_cv_path_CYGPATH
12620 if test -n "$CYGPATH"; then
12621   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12622 $as_echo "$CYGPATH" >&6; }
12623 else
12624   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12625 $as_echo "no" >&6; }
12626 fi
12627 
12628 
12629   test -n "$CYGPATH" && break
12630 done
12631 
12632   else
12633     # The variable is set, but is it from the command line or the environment?
12634 
12635     # Try to remove the string !CYGPATH! from our list.
12636     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
12637     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12638       # If it failed, the variable was not from the command line. Ignore it,
12639       # but warn the user (except for BASH, which is always set by the calling BASH).
12640       if test "xCYGPATH" != xBASH; then
12641         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
12642 $as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
12643       fi
12644       # Try to locate tool using the code snippet
12645       for ac_prog in cygpath
12646 do
12647   # Extract the first word of "$ac_prog", so it can be a program name with args.
12648 set dummy $ac_prog; ac_word=$2
12649 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12650 $as_echo_n "checking for $ac_word... " >&6; }
12651 if ${ac_cv_path_CYGPATH+:} false; then :
12652   $as_echo_n "(cached) " >&6
12653 else
12654   case $CYGPATH in
12655   [\\/]* | ?:[\\/]*)
12656   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12657   ;;
12658   *)
12659   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12660 for as_dir in $PATH
12661 do
12662   IFS=$as_save_IFS
12663   test -z "$as_dir" && as_dir=.
12664     for ac_exec_ext in '' $ac_executable_extensions; do
12665   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12666     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12667     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12668     break 2
12669   fi
12670 done
12671   done
12672 IFS=$as_save_IFS
12673 
12674   ;;
12675 esac
12676 fi
12677 CYGPATH=$ac_cv_path_CYGPATH
12678 if test -n "$CYGPATH"; then
12679   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12680 $as_echo "$CYGPATH" >&6; }
12681 else
12682   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12683 $as_echo "no" >&6; }
12684 fi
12685 
12686 
12687   test -n "$CYGPATH" && break
12688 done
12689 
12690     else
12691       # If it succeeded, then it was overridden by the user. We will use it
12692       # for the tool.
12693 
12694       # First remove it from the list of overridden variables, so we can test
12695       # for unknown variables in the end.
12696       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12697 
12698       # Check if the provided tool contains a complete path.
12699       tool_specified="$CYGPATH"
12700       tool_basename="${tool_specified##*/}"
12701       if test "x$tool_basename" = "x$tool_specified"; then
12702         # A command without a complete path is provided, search $PATH.
12703         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
12704 $as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
12705         # Extract the first word of "$tool_basename", so it can be a program name with args.
12706 set dummy $tool_basename; ac_word=$2
12707 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12708 $as_echo_n "checking for $ac_word... " >&6; }
12709 if ${ac_cv_path_CYGPATH+:} false; then :
12710   $as_echo_n "(cached) " >&6
12711 else
12712   case $CYGPATH in
12713   [\\/]* | ?:[\\/]*)
12714   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12715   ;;
12716   *)
12717   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12718 for as_dir in $PATH
12719 do
12720   IFS=$as_save_IFS
12721   test -z "$as_dir" && as_dir=.
12722     for ac_exec_ext in '' $ac_executable_extensions; do
12723   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12724     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12725     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12726     break 2
12727   fi
12728 done
12729   done
12730 IFS=$as_save_IFS
12731 
12732   ;;
12733 esac
12734 fi
12735 CYGPATH=$ac_cv_path_CYGPATH
12736 if test -n "$CYGPATH"; then
12737   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12738 $as_echo "$CYGPATH" >&6; }
12739 else
12740   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12741 $as_echo "no" >&6; }
12742 fi
12743 
12744 
12745         if test "x$CYGPATH" = x; then
12746           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12747         fi
12748       else
12749         # Otherwise we believe it is a complete path. Use it as it is.
12750         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
12751 $as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
12752         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
12753 $as_echo_n "checking for CYGPATH... " >&6; }
12754         if test ! -x "$tool_specified"; then
12755           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12756 $as_echo "not found" >&6; }
12757           as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
12758         fi
12759         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12760 $as_echo "$tool_specified" >&6; }
12761       fi
12762     fi
12763   fi
12764 
12765 
12766 
12767 
12768   # Publish this variable in the help.
12769 
12770 
12771   if test "x$READLINK" = x; then
12772     # The variable is not set by user, try to locate tool using the code snippet
12773     for ac_prog in greadlink readlink
12774 do
12775   # Extract the first word of "$ac_prog", so it can be a program name with args.
12776 set dummy $ac_prog; ac_word=$2
12777 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12778 $as_echo_n "checking for $ac_word... " >&6; }
12779 if ${ac_cv_path_READLINK+:} false; then :
12780   $as_echo_n "(cached) " >&6
12781 else
12782   case $READLINK in
12783   [\\/]* | ?:[\\/]*)
12784   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12785   ;;
12786   *)
12787   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12788 for as_dir in $PATH
12789 do
12790   IFS=$as_save_IFS
12791   test -z "$as_dir" && as_dir=.
12792     for ac_exec_ext in '' $ac_executable_extensions; do
12793   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12794     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12795     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12796     break 2
12797   fi
12798 done
12799   done
12800 IFS=$as_save_IFS
12801 
12802   ;;
12803 esac
12804 fi
12805 READLINK=$ac_cv_path_READLINK
12806 if test -n "$READLINK"; then
12807   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12808 $as_echo "$READLINK" >&6; }
12809 else
12810   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12811 $as_echo "no" >&6; }
12812 fi
12813 
12814 
12815   test -n "$READLINK" && break
12816 done
12817 
12818   else
12819     # The variable is set, but is it from the command line or the environment?
12820 
12821     # Try to remove the string !READLINK! from our list.
12822     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
12823     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12824       # If it failed, the variable was not from the command line. Ignore it,
12825       # but warn the user (except for BASH, which is always set by the calling BASH).
12826       if test "xREADLINK" != xBASH; then
12827         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
12828 $as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
12829       fi
12830       # Try to locate tool using the code snippet
12831       for ac_prog in greadlink readlink
12832 do
12833   # Extract the first word of "$ac_prog", so it can be a program name with args.
12834 set dummy $ac_prog; ac_word=$2
12835 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12836 $as_echo_n "checking for $ac_word... " >&6; }
12837 if ${ac_cv_path_READLINK+:} false; then :
12838   $as_echo_n "(cached) " >&6
12839 else
12840   case $READLINK in
12841   [\\/]* | ?:[\\/]*)
12842   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12843   ;;
12844   *)
12845   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12846 for as_dir in $PATH
12847 do
12848   IFS=$as_save_IFS
12849   test -z "$as_dir" && as_dir=.
12850     for ac_exec_ext in '' $ac_executable_extensions; do
12851   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12852     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12853     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12854     break 2
12855   fi
12856 done
12857   done
12858 IFS=$as_save_IFS
12859 
12860   ;;
12861 esac
12862 fi
12863 READLINK=$ac_cv_path_READLINK
12864 if test -n "$READLINK"; then
12865   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12866 $as_echo "$READLINK" >&6; }
12867 else
12868   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12869 $as_echo "no" >&6; }
12870 fi
12871 
12872 
12873   test -n "$READLINK" && break
12874 done
12875 
12876     else
12877       # If it succeeded, then it was overridden by the user. We will use it
12878       # for the tool.
12879 
12880       # First remove it from the list of overridden variables, so we can test
12881       # for unknown variables in the end.
12882       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12883 
12884       # Check if the provided tool contains a complete path.
12885       tool_specified="$READLINK"
12886       tool_basename="${tool_specified##*/}"
12887       if test "x$tool_basename" = "x$tool_specified"; then
12888         # A command without a complete path is provided, search $PATH.
12889         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
12890 $as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
12891         # Extract the first word of "$tool_basename", so it can be a program name with args.
12892 set dummy $tool_basename; ac_word=$2
12893 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12894 $as_echo_n "checking for $ac_word... " >&6; }
12895 if ${ac_cv_path_READLINK+:} false; then :
12896   $as_echo_n "(cached) " >&6
12897 else
12898   case $READLINK in
12899   [\\/]* | ?:[\\/]*)
12900   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12901   ;;
12902   *)
12903   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12904 for as_dir in $PATH
12905 do
12906   IFS=$as_save_IFS
12907   test -z "$as_dir" && as_dir=.
12908     for ac_exec_ext in '' $ac_executable_extensions; do
12909   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12910     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12911     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12912     break 2
12913   fi
12914 done
12915   done
12916 IFS=$as_save_IFS
12917 
12918   ;;
12919 esac
12920 fi
12921 READLINK=$ac_cv_path_READLINK
12922 if test -n "$READLINK"; then
12923   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12924 $as_echo "$READLINK" >&6; }
12925 else
12926   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12927 $as_echo "no" >&6; }
12928 fi
12929 
12930 
12931         if test "x$READLINK" = x; then
12932           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12933         fi
12934       else
12935         # Otherwise we believe it is a complete path. Use it as it is.
12936         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
12937 $as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
12938         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
12939 $as_echo_n "checking for READLINK... " >&6; }
12940         if test ! -x "$tool_specified"; then
12941           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12942 $as_echo "not found" >&6; }
12943           as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
12944         fi
12945         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12946 $as_echo "$tool_specified" >&6; }
12947       fi
12948     fi
12949   fi
12950 
12951 
12952 
12953 
12954   # Publish this variable in the help.
12955 
12956 
12957   if test "x$DF" = x; then
12958     # The variable is not set by user, try to locate tool using the code snippet
12959     for ac_prog in df
12960 do
12961   # Extract the first word of "$ac_prog", so it can be a program name with args.
12962 set dummy $ac_prog; ac_word=$2
12963 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12964 $as_echo_n "checking for $ac_word... " >&6; }
12965 if ${ac_cv_path_DF+:} false; then :
12966   $as_echo_n "(cached) " >&6
12967 else
12968   case $DF in
12969   [\\/]* | ?:[\\/]*)
12970   ac_cv_path_DF="$DF" # Let the user override the test with a path.
12971   ;;
12972   *)
12973   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12974 for as_dir in $PATH
12975 do
12976   IFS=$as_save_IFS
12977   test -z "$as_dir" && as_dir=.
12978     for ac_exec_ext in '' $ac_executable_extensions; do
12979   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12980     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12981     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12982     break 2
12983   fi
12984 done
12985   done
12986 IFS=$as_save_IFS
12987 
12988   ;;
12989 esac
12990 fi
12991 DF=$ac_cv_path_DF
12992 if test -n "$DF"; then
12993   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12994 $as_echo "$DF" >&6; }
12995 else
12996   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12997 $as_echo "no" >&6; }
12998 fi
12999 
13000 
13001   test -n "$DF" && break
13002 done
13003 
13004   else
13005     # The variable is set, but is it from the command line or the environment?
13006 
13007     # Try to remove the string !DF! from our list.
13008     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
13009     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13010       # If it failed, the variable was not from the command line. Ignore it,
13011       # but warn the user (except for BASH, which is always set by the calling BASH).
13012       if test "xDF" != xBASH; then
13013         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
13014 $as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
13015       fi
13016       # Try to locate tool using the code snippet
13017       for ac_prog in df
13018 do
13019   # Extract the first word of "$ac_prog", so it can be a program name with args.
13020 set dummy $ac_prog; ac_word=$2
13021 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13022 $as_echo_n "checking for $ac_word... " >&6; }
13023 if ${ac_cv_path_DF+:} false; then :
13024   $as_echo_n "(cached) " >&6
13025 else
13026   case $DF in
13027   [\\/]* | ?:[\\/]*)
13028   ac_cv_path_DF="$DF" # Let the user override the test with a path.
13029   ;;
13030   *)
13031   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13032 for as_dir in $PATH
13033 do
13034   IFS=$as_save_IFS
13035   test -z "$as_dir" && as_dir=.
13036     for ac_exec_ext in '' $ac_executable_extensions; do
13037   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13038     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
13039     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13040     break 2
13041   fi
13042 done
13043   done
13044 IFS=$as_save_IFS
13045 
13046   ;;
13047 esac
13048 fi
13049 DF=$ac_cv_path_DF
13050 if test -n "$DF"; then
13051   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
13052 $as_echo "$DF" >&6; }
13053 else
13054   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13055 $as_echo "no" >&6; }
13056 fi
13057 
13058 
13059   test -n "$DF" && break
13060 done
13061 
13062     else
13063       # If it succeeded, then it was overridden by the user. We will use it
13064       # for the tool.
13065 
13066       # First remove it from the list of overridden variables, so we can test
13067       # for unknown variables in the end.
13068       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13069 
13070       # Check if the provided tool contains a complete path.
13071       tool_specified="$DF"
13072       tool_basename="${tool_specified##*/}"
13073       if test "x$tool_basename" = "x$tool_specified"; then
13074         # A command without a complete path is provided, search $PATH.
13075         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
13076 $as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
13077         # Extract the first word of "$tool_basename", so it can be a program name with args.
13078 set dummy $tool_basename; ac_word=$2
13079 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13080 $as_echo_n "checking for $ac_word... " >&6; }
13081 if ${ac_cv_path_DF+:} false; then :
13082   $as_echo_n "(cached) " >&6
13083 else
13084   case $DF in
13085   [\\/]* | ?:[\\/]*)
13086   ac_cv_path_DF="$DF" # Let the user override the test with a path.
13087   ;;
13088   *)
13089   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13090 for as_dir in $PATH
13091 do
13092   IFS=$as_save_IFS
13093   test -z "$as_dir" && as_dir=.
13094     for ac_exec_ext in '' $ac_executable_extensions; do
13095   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13096     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
13097     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13098     break 2
13099   fi
13100 done
13101   done
13102 IFS=$as_save_IFS
13103 
13104   ;;
13105 esac
13106 fi
13107 DF=$ac_cv_path_DF
13108 if test -n "$DF"; then
13109   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
13110 $as_echo "$DF" >&6; }
13111 else
13112   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13113 $as_echo "no" >&6; }
13114 fi
13115 
13116 
13117         if test "x$DF" = x; then
13118           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13119         fi
13120       else
13121         # Otherwise we believe it is a complete path. Use it as it is.
13122         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
13123 $as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
13124         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
13125 $as_echo_n "checking for DF... " >&6; }
13126         if test ! -x "$tool_specified"; then
13127           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13128 $as_echo "not found" >&6; }
13129           as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
13130         fi
13131         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13132 $as_echo "$tool_specified" >&6; }
13133       fi
13134     fi
13135   fi
13136 
13137 
13138 
13139 
13140   # Publish this variable in the help.
13141 
13142 
13143   if test "x$SETFILE" = x; then
13144     # The variable is not set by user, try to locate tool using the code snippet
13145     for ac_prog in SetFile
13146 do
13147   # Extract the first word of "$ac_prog", so it can be a program name with args.
13148 set dummy $ac_prog; ac_word=$2
13149 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13150 $as_echo_n "checking for $ac_word... " >&6; }
13151 if ${ac_cv_path_SETFILE+:} false; then :
13152   $as_echo_n "(cached) " >&6
13153 else
13154   case $SETFILE in
13155   [\\/]* | ?:[\\/]*)
13156   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13157   ;;
13158   *)
13159   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13160 for as_dir in $PATH
13161 do
13162   IFS=$as_save_IFS
13163   test -z "$as_dir" && as_dir=.
13164     for ac_exec_ext in '' $ac_executable_extensions; do
13165   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13166     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13167     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13168     break 2
13169   fi
13170 done
13171   done
13172 IFS=$as_save_IFS
13173 
13174   ;;
13175 esac
13176 fi
13177 SETFILE=$ac_cv_path_SETFILE
13178 if test -n "$SETFILE"; then
13179   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13180 $as_echo "$SETFILE" >&6; }
13181 else
13182   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13183 $as_echo "no" >&6; }
13184 fi
13185 
13186 
13187   test -n "$SETFILE" && break
13188 done
13189 
13190   else
13191     # The variable is set, but is it from the command line or the environment?
13192 
13193     # Try to remove the string !SETFILE! from our list.
13194     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
13195     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13196       # If it failed, the variable was not from the command line. Ignore it,
13197       # but warn the user (except for BASH, which is always set by the calling BASH).
13198       if test "xSETFILE" != xBASH; then
13199         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
13200 $as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
13201       fi
13202       # Try to locate tool using the code snippet
13203       for ac_prog in SetFile
13204 do
13205   # Extract the first word of "$ac_prog", so it can be a program name with args.
13206 set dummy $ac_prog; ac_word=$2
13207 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13208 $as_echo_n "checking for $ac_word... " >&6; }
13209 if ${ac_cv_path_SETFILE+:} false; then :
13210   $as_echo_n "(cached) " >&6
13211 else
13212   case $SETFILE in
13213   [\\/]* | ?:[\\/]*)
13214   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13215   ;;
13216   *)
13217   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13218 for as_dir in $PATH
13219 do
13220   IFS=$as_save_IFS
13221   test -z "$as_dir" && as_dir=.
13222     for ac_exec_ext in '' $ac_executable_extensions; do
13223   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13224     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13225     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13226     break 2
13227   fi
13228 done
13229   done
13230 IFS=$as_save_IFS
13231 
13232   ;;
13233 esac
13234 fi
13235 SETFILE=$ac_cv_path_SETFILE
13236 if test -n "$SETFILE"; then
13237   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13238 $as_echo "$SETFILE" >&6; }
13239 else
13240   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13241 $as_echo "no" >&6; }
13242 fi
13243 
13244 
13245   test -n "$SETFILE" && break
13246 done
13247 
13248     else
13249       # If it succeeded, then it was overridden by the user. We will use it
13250       # for the tool.
13251 
13252       # First remove it from the list of overridden variables, so we can test
13253       # for unknown variables in the end.
13254       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13255 
13256       # Check if the provided tool contains a complete path.
13257       tool_specified="$SETFILE"
13258       tool_basename="${tool_specified##*/}"
13259       if test "x$tool_basename" = "x$tool_specified"; then
13260         # A command without a complete path is provided, search $PATH.
13261         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
13262 $as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
13263         # Extract the first word of "$tool_basename", so it can be a program name with args.
13264 set dummy $tool_basename; ac_word=$2
13265 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13266 $as_echo_n "checking for $ac_word... " >&6; }
13267 if ${ac_cv_path_SETFILE+:} false; then :
13268   $as_echo_n "(cached) " >&6
13269 else
13270   case $SETFILE in
13271   [\\/]* | ?:[\\/]*)
13272   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13273   ;;
13274   *)
13275   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13276 for as_dir in $PATH
13277 do
13278   IFS=$as_save_IFS
13279   test -z "$as_dir" && as_dir=.
13280     for ac_exec_ext in '' $ac_executable_extensions; do
13281   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13282     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13283     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13284     break 2
13285   fi
13286 done
13287   done
13288 IFS=$as_save_IFS
13289 
13290   ;;
13291 esac
13292 fi
13293 SETFILE=$ac_cv_path_SETFILE
13294 if test -n "$SETFILE"; then
13295   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13296 $as_echo "$SETFILE" >&6; }
13297 else
13298   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13299 $as_echo "no" >&6; }
13300 fi
13301 
13302 
13303         if test "x$SETFILE" = x; then
13304           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13305         fi
13306       else
13307         # Otherwise we believe it is a complete path. Use it as it is.
13308         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
13309 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
13310         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
13311 $as_echo_n "checking for SETFILE... " >&6; }
13312         if test ! -x "$tool_specified"; then
13313           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13314 $as_echo "not found" >&6; }
13315           as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
13316         fi
13317         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13318 $as_echo "$tool_specified" >&6; }
13319       fi
13320     fi
13321   fi
13322 
13323 
13324 
13325 
13326 # Now we can determine OpenJDK build and target platforms. This is required to
13327 # have early on.
13328 # Make sure we can run config.sub.
13329 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
13330   as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
13331 
13332 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
13333 $as_echo_n "checking build system type... " >&6; }
13334 if ${ac_cv_build+:} false; then :
13335   $as_echo_n "(cached) " >&6
13336 else
13337   ac_build_alias=$build_alias
13338 test "x$ac_build_alias" = x &&
13339   ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
13340 test "x$ac_build_alias" = x &&
13341   as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
13342 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
13343   as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
13344 
13345 fi
13346 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
13347 $as_echo "$ac_cv_build" >&6; }
13348 case $ac_cv_build in
13349 *-*-*) ;;
13350 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
13351 esac
13352 build=$ac_cv_build
13353 ac_save_IFS=$IFS; IFS='-'
13354 set x $ac_cv_build
13355 shift
13356 build_cpu=$1
13357 build_vendor=$2
13358 shift; shift
13359 # Remember, the first character of IFS is used to create $*,
13360 # except with old shells:
13361 build_os=$*
13362 IFS=$ac_save_IFS
13363 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
13364 
13365 
13366 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
13367 $as_echo_n "checking host system type... " >&6; }
13368 if ${ac_cv_host+:} false; then :
13369   $as_echo_n "(cached) " >&6
13370 else
13371   if test "x$host_alias" = x; then
13372   ac_cv_host=$ac_cv_build
13373 else
13374   ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
13375     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
13376 fi
13377 
13378 fi
13379 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
13380 $as_echo "$ac_cv_host" >&6; }
13381 case $ac_cv_host in
13382 *-*-*) ;;
13383 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
13384 esac
13385 host=$ac_cv_host
13386 ac_save_IFS=$IFS; IFS='-'
13387 set x $ac_cv_host
13388 shift
13389 host_cpu=$1
13390 host_vendor=$2
13391 shift; shift
13392 # Remember, the first character of IFS is used to create $*,
13393 # except with old shells:
13394 host_os=$*
13395 IFS=$ac_save_IFS
13396 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
13397 
13398 
13399 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
13400 $as_echo_n "checking target system type... " >&6; }
13401 if ${ac_cv_target+:} false; then :
13402   $as_echo_n "(cached) " >&6
13403 else
13404   if test "x$target_alias" = x; then
13405   ac_cv_target=$ac_cv_host
13406 else
13407   ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
13408     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
13409 fi
13410 
13411 fi
13412 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
13413 $as_echo "$ac_cv_target" >&6; }
13414 case $ac_cv_target in
13415 *-*-*) ;;
13416 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
13417 esac
13418 target=$ac_cv_target
13419 ac_save_IFS=$IFS; IFS='-'
13420 set x $ac_cv_target
13421 shift
13422 target_cpu=$1
13423 target_vendor=$2
13424 shift; shift
13425 # Remember, the first character of IFS is used to create $*,
13426 # except with old shells:
13427 target_os=$*
13428 IFS=$ac_save_IFS
13429 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
13430 
13431 
13432 # The aliases save the names the user supplied, while $host etc.
13433 # will get canonicalized.
13434 test -n "$target_alias" &&
13435   test "$program_prefix$program_suffix$program_transform_name" = \
13436     NONENONEs,x,x, &&
13437   program_prefix=${target_alias}-
13438 
13439   # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
13440   # is confusing; it assumes you are cross-compiling a cross-compiler (!)  and "target" is thus the target of the
13441   # product you're building. The target of this build is called "host". Since this is confusing to most people, we
13442   # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
13443   # to use the configure naming style.
13444 
13445 
13446 
13447 
13448 
13449   # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
13450   # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
13451   # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
13452   # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
13453   OPENJDK_TARGET_AUTOCONF_NAME="$host"
13454   OPENJDK_BUILD_AUTOCONF_NAME="$build"
13455 
13456 
13457 
13458   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13459 
13460   case "$build_os" in
13461     *linux*)
13462       VAR_OS=linux
13463       VAR_OS_API=posix
13464       VAR_OS_ENV=linux
13465       ;;
13466     *solaris*)
13467       VAR_OS=solaris
13468       VAR_OS_API=posix
13469       VAR_OS_ENV=solaris
13470       ;;
13471     *darwin*)
13472       VAR_OS=macosx
13473       VAR_OS_API=posix
13474       VAR_OS_ENV=macosx
13475       ;;
13476     *bsd*)
13477       VAR_OS=bsd
13478       VAR_OS_API=posix
13479       VAR_OS_ENV=bsd
13480       ;;
13481     *cygwin*)
13482       VAR_OS=windows
13483       VAR_OS_API=winapi
13484       VAR_OS_ENV=windows.cygwin
13485       ;;
13486     *mingw*)
13487       VAR_OS=windows
13488       VAR_OS_API=winapi
13489       VAR_OS_ENV=windows.msys
13490       ;;
13491     *aix*)
13492       VAR_OS=aix
13493       VAR_OS_API=posix
13494       VAR_OS_ENV=aix
13495       ;;
13496     *)
13497       as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
13498       ;;
13499   esac
13500 
13501 
13502   # First argument is the cpu name from the trip/quad
13503   case "$build_cpu" in
13504     x86_64)
13505       VAR_CPU=x86_64
13506       VAR_CPU_ARCH=x86
13507       VAR_CPU_BITS=64
13508       VAR_CPU_ENDIAN=little
13509       ;;
13510     i?86)
13511       VAR_CPU=x86
13512       VAR_CPU_ARCH=x86
13513       VAR_CPU_BITS=32
13514       VAR_CPU_ENDIAN=little
13515       ;;
13516     arm*)
13517       VAR_CPU=arm
13518       VAR_CPU_ARCH=arm
13519       VAR_CPU_BITS=32
13520       VAR_CPU_ENDIAN=little
13521       ;;
13522     powerpc)
13523       VAR_CPU=ppc
13524       VAR_CPU_ARCH=ppc
13525       VAR_CPU_BITS=32
13526       VAR_CPU_ENDIAN=big
13527       ;;
13528     powerpc64)
13529       VAR_CPU=ppc64
13530       VAR_CPU_ARCH=ppc
13531       VAR_CPU_BITS=64
13532       VAR_CPU_ENDIAN=big
13533       ;;
13534     powerpc64le)
13535       VAR_CPU=ppc64
13536       VAR_CPU_ARCH=ppc
13537       VAR_CPU_BITS=64
13538       VAR_CPU_ENDIAN=little
13539       ;;
13540     s390)
13541       VAR_CPU=s390
13542       VAR_CPU_ARCH=s390
13543       VAR_CPU_BITS=32
13544       VAR_CPU_ENDIAN=big
13545       ;;
13546     s390x)
13547       VAR_CPU=s390x
13548       VAR_CPU_ARCH=s390
13549       VAR_CPU_BITS=64
13550       VAR_CPU_ENDIAN=big
13551       ;;
13552     sparc)
13553       VAR_CPU=sparc
13554       VAR_CPU_ARCH=sparc
13555       VAR_CPU_BITS=32
13556       VAR_CPU_ENDIAN=big
13557       ;;
13558     sparcv9)
13559       VAR_CPU=sparcv9
13560       VAR_CPU_ARCH=sparc
13561       VAR_CPU_BITS=64
13562       VAR_CPU_ENDIAN=big
13563       ;;
13564     *)
13565       as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
13566       ;;
13567   esac
13568 
13569   # ..and setup our own variables. (Do this explicitely to facilitate searching)
13570   OPENJDK_BUILD_OS="$VAR_OS"
13571   OPENJDK_BUILD_OS_API="$VAR_OS_API"
13572   OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
13573   OPENJDK_BUILD_CPU="$VAR_CPU"
13574   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
13575   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
13576   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13577 
13578 
13579 
13580 
13581 
13582 
13583 
13584   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
13585 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
13586   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
13587 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
13588 
13589   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13590 
13591   case "$host_os" in
13592     *linux*)
13593       VAR_OS=linux
13594       VAR_OS_API=posix
13595       VAR_OS_ENV=linux
13596       ;;
13597     *solaris*)
13598       VAR_OS=solaris
13599       VAR_OS_API=posix
13600       VAR_OS_ENV=solaris
13601       ;;
13602     *darwin*)
13603       VAR_OS=macosx
13604       VAR_OS_API=posix
13605       VAR_OS_ENV=macosx
13606       ;;
13607     *bsd*)
13608       VAR_OS=bsd
13609       VAR_OS_API=posix
13610       VAR_OS_ENV=bsd
13611       ;;
13612     *cygwin*)
13613       VAR_OS=windows
13614       VAR_OS_API=winapi
13615       VAR_OS_ENV=windows.cygwin
13616       ;;
13617     *mingw*)
13618       VAR_OS=windows
13619       VAR_OS_API=winapi
13620       VAR_OS_ENV=windows.msys
13621       ;;
13622     *aix*)
13623       VAR_OS=aix
13624       VAR_OS_API=posix
13625       VAR_OS_ENV=aix
13626       ;;
13627     *)
13628       as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
13629       ;;
13630   esac
13631 
13632 
13633   # First argument is the cpu name from the trip/quad
13634   case "$host_cpu" in
13635     x86_64)
13636       VAR_CPU=x86_64
13637       VAR_CPU_ARCH=x86
13638       VAR_CPU_BITS=64
13639       VAR_CPU_ENDIAN=little
13640       ;;
13641     i?86)
13642       VAR_CPU=x86
13643       VAR_CPU_ARCH=x86
13644       VAR_CPU_BITS=32
13645       VAR_CPU_ENDIAN=little
13646       ;;
13647     arm*)
13648       VAR_CPU=arm
13649       VAR_CPU_ARCH=arm
13650       VAR_CPU_BITS=32
13651       VAR_CPU_ENDIAN=little
13652       ;;
13653     powerpc)
13654       VAR_CPU=ppc
13655       VAR_CPU_ARCH=ppc
13656       VAR_CPU_BITS=32
13657       VAR_CPU_ENDIAN=big
13658       ;;
13659     powerpc64)
13660       VAR_CPU=ppc64
13661       VAR_CPU_ARCH=ppc
13662       VAR_CPU_BITS=64
13663       VAR_CPU_ENDIAN=big
13664       ;;
13665     powerpc64le)
13666       VAR_CPU=ppc64
13667       VAR_CPU_ARCH=ppc
13668       VAR_CPU_BITS=64
13669       VAR_CPU_ENDIAN=little
13670       ;;
13671     s390)
13672       VAR_CPU=s390
13673       VAR_CPU_ARCH=s390
13674       VAR_CPU_BITS=32
13675       VAR_CPU_ENDIAN=big
13676       ;;
13677     s390x)
13678       VAR_CPU=s390x
13679       VAR_CPU_ARCH=s390
13680       VAR_CPU_BITS=64
13681       VAR_CPU_ENDIAN=big
13682       ;;
13683     sparc)
13684       VAR_CPU=sparc
13685       VAR_CPU_ARCH=sparc
13686       VAR_CPU_BITS=32
13687       VAR_CPU_ENDIAN=big
13688       ;;
13689     sparcv9)
13690       VAR_CPU=sparcv9
13691       VAR_CPU_ARCH=sparc
13692       VAR_CPU_BITS=64
13693       VAR_CPU_ENDIAN=big
13694       ;;
13695     *)
13696       as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
13697       ;;
13698   esac
13699 
13700   # ... and setup our own variables. (Do this explicitely to facilitate searching)
13701   OPENJDK_TARGET_OS="$VAR_OS"
13702   OPENJDK_TARGET_OS_API="$VAR_OS_API"
13703   OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
13704   OPENJDK_TARGET_CPU="$VAR_CPU"
13705   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
13706   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
13707   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13708 
13709 
13710 
13711 
13712 
13713 
13714 
13715   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
13716 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
13717   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
13718 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
13719 
13720 
13721 
13722 # Check whether --with-target-bits was given.
13723 if test "${with_target_bits+set}" = set; then :
13724   withval=$with_target_bits;
13725 fi
13726 
13727 
13728   # We have three types of compiles:
13729   # native  == normal compilation, target system == build system
13730   # cross   == traditional cross compilation, target system != build system; special toolchain needed
13731   # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
13732   #
13733   if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
13734     # We're doing a proper cross-compilation
13735     COMPILE_TYPE="cross"
13736   else
13737     COMPILE_TYPE="native"
13738   fi
13739 
13740   if test "x$with_target_bits" != x; then
13741     if test "x$COMPILE_TYPE" = "xcross"; then
13742       as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
13743     fi
13744 
13745     if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13746       # A reduced build is requested
13747       COMPILE_TYPE="reduced"
13748       OPENJDK_TARGET_CPU_BITS=32
13749       if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
13750         OPENJDK_TARGET_CPU=x86
13751       elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
13752         OPENJDK_TARGET_CPU=sparc
13753       else
13754         as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
13755       fi
13756     elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
13757       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
13758     elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
13759       { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
13760 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
13761     else
13762       as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
13763     fi
13764   fi
13765 
13766 
13767   { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
13768 $as_echo_n "checking compilation type... " >&6; }
13769   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
13770 $as_echo "$COMPILE_TYPE" >&6; }
13771 
13772 
13773   if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
13774     REQUIRED_OS_NAME=SunOS
13775     REQUIRED_OS_VERSION=5.10
13776   fi
13777   if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
13778     REQUIRED_OS_NAME=Linux
13779     REQUIRED_OS_VERSION=2.6
13780   fi
13781   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
13782     REQUIRED_OS_NAME=Windows
13783     if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
13784       REQUIRED_OS_VERSION=5.2
13785     else
13786       REQUIRED_OS_VERSION=5.1
13787     fi
13788   fi
13789   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
13790     REQUIRED_OS_NAME=Darwin
13791     REQUIRED_OS_VERSION=11.2
13792   fi
13793 
13794 
13795 
13796 
13797 
13798   # Also store the legacy naming of the cpu.
13799   # Ie i586 and amd64 instead of x86 and x86_64
13800   OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
13801   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13802     OPENJDK_TARGET_CPU_LEGACY="i586"
13803   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13804     # On all platforms except MacOSX replace x86_64 with amd64.
13805     OPENJDK_TARGET_CPU_LEGACY="amd64"
13806   fi
13807 
13808 
13809   # And the second legacy naming of the cpu.
13810   # Ie i386 and amd64 instead of x86 and x86_64.
13811   OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
13812   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13813     OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
13814   elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13815     OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
13816   fi
13817 
13818 
13819   # This is the name of the cpu (but using i386 and amd64 instead of
13820   # x86 and x86_64, respectively), preceeded by a /, to be used when
13821   # locating libraries. On macosx, it's empty, though.
13822   OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
13823   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13824     OPENJDK_TARGET_CPU_LIBDIR=""
13825   fi
13826 
13827 
13828   # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
13829   # /amd64 or /sparcv9. This string is appended to some library paths, like this:
13830   # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
13831   OPENJDK_TARGET_CPU_ISADIR=""
13832   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13833     if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13834       OPENJDK_TARGET_CPU_ISADIR="/amd64"
13835     elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
13836       OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
13837     fi
13838   fi
13839 
13840 
13841   # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
13842   OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
13843   if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
13844     # On linux only, we replace x86 with i386.
13845     OPENJDK_TARGET_CPU_OSARCH="i386"
13846   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13847     # On all platforms except macosx, we replace x86_64 with amd64.
13848     OPENJDK_TARGET_CPU_OSARCH="amd64"
13849   fi
13850 
13851 
13852   OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
13853   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13854     OPENJDK_TARGET_CPU_JLI="i386"
13855   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13856     # On all platforms except macosx, we replace x86_64 with amd64.
13857     OPENJDK_TARGET_CPU_JLI="amd64"
13858   fi
13859   # Now setup the -D flags for building libjli.
13860   OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
13861   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13862     if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
13863       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
13864     elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
13865       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
13866     fi
13867   fi
13868 
13869 
13870   # Setup OPENJDK_TARGET_OS_API_DIR, used in source paths.
13871   if test "x$OPENJDK_TARGET_OS_API" = xposix; then
13872     OPENJDK_TARGET_OS_API_DIR="solaris"
13873   fi
13874   if test "x$OPENJDK_TARGET_OS_API" = xwinapi; then
13875     OPENJDK_TARGET_OS_API_DIR="windows"
13876   fi
13877 
13878 
13879   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13880       OPENJDK_TARGET_OS_EXPORT_DIR=macosx
13881   else
13882       OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_API_DIR}
13883   fi
13884 
13885 
13886   if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13887     A_LP64="LP64:="
13888     # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
13889     # unpack200.exe
13890     if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
13891       ADD_LP64="-D_LP64=1"
13892     fi
13893   fi
13894   LP64=$A_LP64
13895 
13896 
13897   if test "x$COMPILE_TYPE" = "xcross"; then
13898     # FIXME: ... or should this include reduced builds..?
13899     DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
13900   else
13901     DEFINE_CROSS_COMPILE_ARCH=""
13902   fi
13903 
13904 
13905   # ZERO_ARCHDEF is used to enable architecture-specific code
13906   case "${OPENJDK_TARGET_CPU}" in
13907     ppc*)    ZERO_ARCHDEF=PPC   ;;
13908     s390*)   ZERO_ARCHDEF=S390  ;;
13909     sparc*)  ZERO_ARCHDEF=SPARC ;;
13910     x86_64*) ZERO_ARCHDEF=AMD64 ;;
13911     x86)     ZERO_ARCHDEF=IA32  ;;
13912     *)      ZERO_ARCHDEF=$(echo "${OPENJDK_TARGET_CPU_LEGACY_LIB}" | tr a-z A-Z)
13913   esac
13914 
13915 
13916 
13917 
13918 # Continue setting up basic stuff. Most remaining code require fundamental tools.
13919 
13920   # Save the current directory this script was started from
13921   CURDIR="$PWD"
13922 
13923   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
13924     PATH_SEP=";"
13925 
13926   SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
13927   if test $SRC_ROOT_LENGTH -gt 100; then
13928     as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
13929   fi
13930 
13931   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13932     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
13933 $as_echo_n "checking cygwin release... " >&6; }
13934     CYGWIN_VERSION=`$UNAME -r`
13935     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
13936 $as_echo "$CYGWIN_VERSION" >&6; }
13937     WINDOWS_ENV_VENDOR='cygwin'
13938     WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
13939 
13940     CYGWIN_VERSION_OK=`$ECHO $CYGWIN_VERSION | $GREP ^1.7.`
13941     if test "x$CYGWIN_VERSION_OK" = x; then
13942       { $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
13943 $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;}
13944       as_fn_error $? "Cannot continue" "$LINENO" 5
13945     fi
13946     if test "x$CYGPATH" = x; then
13947       as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
13948     fi
13949     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
13950 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
13951     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
13952     cygwin_winpath_root=`cd / ; cmd /c cd | grep ".*"`
13953     # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
13954     CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
13955     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
13956 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
13957     WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
13958     test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
13959     if test "x$test_cygdrive_prefix" = x; then
13960       as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
13961     fi
13962   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
13963     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
13964 $as_echo_n "checking msys release... " >&6; }
13965     MSYS_VERSION=`$UNAME -r`
13966     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
13967 $as_echo "$MSYS_VERSION" >&6; }
13968 
13969     WINDOWS_ENV_VENDOR='msys'
13970     WINDOWS_ENV_VERSION="$MSYS_VERSION"
13971 
13972     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
13973 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
13974     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
13975     MSYS_ROOT_PATH=`cd / ; cmd /c cd | grep ".*"`
13976 
13977   windows_path="$MSYS_ROOT_PATH"
13978   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13979     unix_path=`$CYGPATH -u "$windows_path"`
13980     MSYS_ROOT_PATH="$unix_path"
13981   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
13982     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
13983     MSYS_ROOT_PATH="$unix_path"
13984   fi
13985 
13986     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
13987 $as_echo "$MSYS_ROOT_PATH" >&6; }
13988     WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
13989   else
13990     as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
13991   fi
13992 
13993   # Test if windows or unix (cygwin/msys) find is first in path.
13994   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
13995 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
13996   FIND_BINARY_OUTPUT=`find --version 2>&1`
13997   if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
13998     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
13999 $as_echo "unix style" >&6; }
14000   elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
14001     { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
14002 $as_echo "Windows" >&6; }
14003     { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
14004 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
14005     { $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
14006 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
14007     as_fn_error $? "Cannot continue" "$LINENO" 5
14008   else
14009     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
14010 $as_echo "unknown" >&6; }
14011     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
14012 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
14013   fi
14014 
14015   else
14016     PATH_SEP=":"
14017   fi
14018 
14019 
14020   # We get the top-level directory from the supporting wrappers.
14021   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
14022 $as_echo_n "checking for top-level directory... " >&6; }
14023   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
14024 $as_echo "$TOPDIR" >&6; }
14025 
14026 
14027   # We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
14028 
14029   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14030 
14031   # Input might be given as Windows format, start by converting to
14032   # unix format.
14033   path="$CURDIR"
14034   new_path=`$CYGPATH -u "$path"`
14035 
14036   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14037   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14038   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14039   # "foo.exe" is OK but "foo" is an error.
14040   #
14041   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14042   # It is also a way to make sure we got the proper file name for the real test later on.
14043   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14044   if test "x$test_shortpath" = x; then
14045     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14046 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14047     as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
14048   fi
14049 
14050   # Call helper function which possibly converts this using DOS-style short mode.
14051   # If so, the updated path is stored in $new_path.
14052 
14053   input_path="$new_path"
14054   # Check if we need to convert this using DOS-style short mode. If the path
14055   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14056   # take no chances and rewrite it.
14057   # Note: m4 eats our [], so we need to use [ and ] instead.
14058   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14059   if test "x$has_forbidden_chars" != x; then
14060     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14061     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14062     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14063     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14064       # Going to short mode and back again did indeed matter. Since short mode is
14065       # case insensitive, let's make it lowercase to improve readability.
14066       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14067       # Now convert it back to Unix-stile (cygpath)
14068       input_path=`$CYGPATH -u "$shortmode_path"`
14069       new_path="$input_path"
14070     fi
14071   fi
14072 
14073   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14074   if test "x$test_cygdrive_prefix" = x; then
14075     # As a simple fix, exclude /usr/bin since it's not a real path.
14076     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14077       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14078       # a path prefixed by /cygdrive for fixpath to work.
14079       new_path="$CYGWIN_ROOT_PATH$input_path"
14080     fi
14081   fi
14082 
14083 
14084   if test "x$path" != "x$new_path"; then
14085     CURDIR="$new_path"
14086     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14087 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14088   fi
14089 
14090   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14091 
14092   path="$CURDIR"
14093   has_colon=`$ECHO $path | $GREP ^.:`
14094   new_path="$path"
14095   if test "x$has_colon" = x; then
14096     # Not in mixed or Windows style, start by that.
14097     new_path=`cmd //c echo $path`
14098   fi
14099 
14100 
14101   input_path="$new_path"
14102   # Check if we need to convert this using DOS-style short mode. If the path
14103   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14104   # take no chances and rewrite it.
14105   # Note: m4 eats our [], so we need to use [ and ] instead.
14106   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14107   if test "x$has_forbidden_chars" != x; then
14108     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14109     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14110   fi
14111 
14112 
14113   windows_path="$new_path"
14114   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14115     unix_path=`$CYGPATH -u "$windows_path"`
14116     new_path="$unix_path"
14117   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14118     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14119     new_path="$unix_path"
14120   fi
14121 
14122   if test "x$path" != "x$new_path"; then
14123     CURDIR="$new_path"
14124     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14125 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14126   fi
14127 
14128   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14129   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14130 
14131   else
14132     # We're on a posix platform. Hooray! :)
14133     path="$CURDIR"
14134     has_space=`$ECHO "$path" | $GREP " "`
14135     if test "x$has_space" != x; then
14136       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14137 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14138       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14139     fi
14140 
14141     # Use eval to expand a potential ~
14142     eval path="$path"
14143     if test ! -f "$path" && test ! -d "$path"; then
14144       as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14145     fi
14146 
14147     CURDIR="`cd "$path"; $THEPWDCMD -L`"
14148   fi
14149 
14150 
14151   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14152 
14153   # Input might be given as Windows format, start by converting to
14154   # unix format.
14155   path="$TOPDIR"
14156   new_path=`$CYGPATH -u "$path"`
14157 
14158   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14159   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14160   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14161   # "foo.exe" is OK but "foo" is an error.
14162   #
14163   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14164   # It is also a way to make sure we got the proper file name for the real test later on.
14165   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14166   if test "x$test_shortpath" = x; then
14167     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14168 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14169     as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
14170   fi
14171 
14172   # Call helper function which possibly converts this using DOS-style short mode.
14173   # If so, the updated path is stored in $new_path.
14174 
14175   input_path="$new_path"
14176   # Check if we need to convert this using DOS-style short mode. If the path
14177   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14178   # take no chances and rewrite it.
14179   # Note: m4 eats our [], so we need to use [ and ] instead.
14180   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14181   if test "x$has_forbidden_chars" != x; then
14182     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14183     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14184     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14185     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14186       # Going to short mode and back again did indeed matter. Since short mode is
14187       # case insensitive, let's make it lowercase to improve readability.
14188       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14189       # Now convert it back to Unix-stile (cygpath)
14190       input_path=`$CYGPATH -u "$shortmode_path"`
14191       new_path="$input_path"
14192     fi
14193   fi
14194 
14195   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14196   if test "x$test_cygdrive_prefix" = x; then
14197     # As a simple fix, exclude /usr/bin since it's not a real path.
14198     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14199       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14200       # a path prefixed by /cygdrive for fixpath to work.
14201       new_path="$CYGWIN_ROOT_PATH$input_path"
14202     fi
14203   fi
14204 
14205 
14206   if test "x$path" != "x$new_path"; then
14207     TOPDIR="$new_path"
14208     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14209 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14210   fi
14211 
14212   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14213 
14214   path="$TOPDIR"
14215   has_colon=`$ECHO $path | $GREP ^.:`
14216   new_path="$path"
14217   if test "x$has_colon" = x; then
14218     # Not in mixed or Windows style, start by that.
14219     new_path=`cmd //c echo $path`
14220   fi
14221 
14222 
14223   input_path="$new_path"
14224   # Check if we need to convert this using DOS-style short mode. If the path
14225   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14226   # take no chances and rewrite it.
14227   # Note: m4 eats our [], so we need to use [ and ] instead.
14228   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14229   if test "x$has_forbidden_chars" != x; then
14230     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14231     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14232   fi
14233 
14234 
14235   windows_path="$new_path"
14236   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14237     unix_path=`$CYGPATH -u "$windows_path"`
14238     new_path="$unix_path"
14239   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14240     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14241     new_path="$unix_path"
14242   fi
14243 
14244   if test "x$path" != "x$new_path"; then
14245     TOPDIR="$new_path"
14246     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14247 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14248   fi
14249 
14250   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14251   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14252 
14253   else
14254     # We're on a posix platform. Hooray! :)
14255     path="$TOPDIR"
14256     has_space=`$ECHO "$path" | $GREP " "`
14257     if test "x$has_space" != x; then
14258       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14259 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14260       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14261     fi
14262 
14263     # Use eval to expand a potential ~
14264     eval path="$path"
14265     if test ! -f "$path" && test ! -d "$path"; then
14266       as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14267     fi
14268 
14269     TOPDIR="`cd "$path"; $THEPWDCMD -L`"
14270   fi
14271 
14272   # SRC_ROOT is a traditional alias for TOPDIR.
14273   SRC_ROOT=$TOPDIR
14274 
14275   # Locate the directory of this script.
14276   AUTOCONF_DIR=$TOPDIR/common/autoconf
14277 
14278 
14279   # Setup default logging of stdout and stderr to build.log in the output root.
14280   BUILD_LOG='$(OUTPUT_ROOT)/build.log'
14281   BUILD_LOG_PREVIOUS='$(OUTPUT_ROOT)/build.log.old'
14282   BUILD_LOG_WRAPPER='$(BASH) $(SRC_ROOT)/common/bin/logger.sh $(BUILD_LOG)'
14283 
14284 
14285 
14286 
14287 
14288 # Check if it's a pure open build or if custom sources are to be used.
14289 
14290   # Check whether --enable-openjdk-only was given.
14291 if test "${enable_openjdk_only+set}" = set; then :
14292   enableval=$enable_openjdk_only;
14293 else
14294   enable_openjdk_only="no"
14295 fi
14296 
14297 
14298   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
14299 $as_echo_n "checking for presence of closed sources... " >&6; }
14300   if test -d "$SRC_ROOT/jdk/src/closed"; then
14301     CLOSED_SOURCE_PRESENT=yes
14302   else
14303     CLOSED_SOURCE_PRESENT=no
14304   fi
14305   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
14306 $as_echo "$CLOSED_SOURCE_PRESENT" >&6; }
14307 
14308   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
14309 $as_echo_n "checking if closed source is suppressed (openjdk-only)... " >&6; }
14310   SUPPRESS_CLOSED_SOURCE="$enable_openjdk_only"
14311   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
14312 $as_echo "$SUPPRESS_CLOSED_SOURCE" >&6; }
14313 
14314   if test "x$CLOSED_SOURCE_PRESENT" = xno; then
14315     OPENJDK=true
14316     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14317       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
14318 $as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
14319     fi
14320   else
14321     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14322       OPENJDK=true
14323     else
14324       OPENJDK=false
14325     fi
14326   fi
14327 
14328   if test "x$OPENJDK" = "xtrue"; then
14329     SET_OPENJDK="OPENJDK=true"
14330   fi
14331 
14332 
14333 
14334   # custom-make-dir is deprecated. Please use your custom-hook.m4 to override
14335   # the IncludeCustomExtension macro.
14336 
14337 
14338 # Check whether --with-custom-make-dir was given.
14339 if test "${with_custom_make_dir+set}" = set; then :
14340   withval=$with_custom_make_dir; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&5
14341 $as_echo "$as_me: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&2;}
14342 fi
14343 
14344 
14345 
14346 
14347 # These are needed to be able to create a configuration name (and thus the output directory)
14348 
14349   ###############################################################################
14350   #
14351   # Check which variant of the JDK that we want to build.
14352   # Currently we have:
14353   #    normal:   standard edition
14354   # but the custom make system may add other variants
14355   #
14356   # Effectively the JDK variant gives a name to a specific set of
14357   # modules to compile into the JDK. In the future, these modules
14358   # might even be Jigsaw modules.
14359   #
14360   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
14361 $as_echo_n "checking which variant of the JDK to build... " >&6; }
14362 
14363 # Check whether --with-jdk-variant was given.
14364 if test "${with_jdk_variant+set}" = set; then :
14365   withval=$with_jdk_variant;
14366 fi
14367 
14368 
14369   if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
14370     JDK_VARIANT="normal"
14371   else
14372     as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
14373   fi
14374 
14375 
14376 
14377   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
14378 $as_echo "$JDK_VARIANT" >&6; }
14379 
14380 
14381 ###############################################################################
14382 #
14383 # Check which interpreter of the JVM we want to build.
14384 # Currently we have:
14385 #    template: Template interpreter (the default)
14386 #    cpp     : C++ interpreter
14387 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which interpreter of the JVM to build" >&5
14388 $as_echo_n "checking which interpreter of the JVM to build... " >&6; }
14389 
14390 # Check whether --with-jvm-interpreter was given.
14391 if test "${with_jvm_interpreter+set}" = set; then :
14392   withval=$with_jvm_interpreter;
14393 fi
14394 
14395 
14396 if test "x$with_jvm_interpreter" = x; then
14397      with_jvm_interpreter="template"
14398 fi
14399 
14400 JVM_INTERPRETER="$with_jvm_interpreter"
14401 
14402 if test "x$JVM_INTERPRETER" != xtemplate && test "x$JVM_INTERPRETER" != xcpp; then
14403    as_fn_error $? "The available JVM interpreters are: template, cpp" "$LINENO" 5
14404 fi
14405 
14406 
14407 
14408 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_interpreter" >&5
14409 $as_echo "$with_jvm_interpreter" >&6; }
14410 
14411 
14412 
14413   ###############################################################################
14414   #
14415   # Check which variants of the JVM that we want to build.
14416   # Currently we have:
14417   #    server: normal interpreter and a tiered C1/C2 compiler
14418   #    client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms)
14419   #    minimal1: reduced form of client with optional VM services and features stripped out
14420   #    kernel: kernel footprint JVM that passes the TCK without major performance problems,
14421   #             ie normal interpreter and C1, only the serial GC, kernel jvmti etc
14422   #    zero: no machine code interpreter, no compiler
14423   #    zeroshark: zero interpreter and shark/llvm compiler backend
14424 #    core: interpreter only, no compiler (only works on some platforms)
14425   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
14426 $as_echo_n "checking which variants of the JVM to build... " >&6; }
14427 
14428 # Check whether --with-jvm-variants was given.
14429 if test "${with_jvm_variants+set}" = set; then :
14430   withval=$with_jvm_variants;
14431 fi
14432 
14433 
14434   if test "x$with_jvm_variants" = x; then
14435     with_jvm_variants="server"
14436   fi
14437 
14438   JVM_VARIANTS=",$with_jvm_variants,"
14439   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,//'`
14440 
14441   if test "x$TEST_VARIANTS" != "x,"; then
14442      as_fn_error $? "The available JVM variants are: server, client, minimal1, kernel, zero, zeroshark, core" "$LINENO" 5
14443   fi
14444   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5
14445 $as_echo "$with_jvm_variants" >&6; }
14446 
14447   JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'`
14448   JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'`
14449   JVM_VARIANT_MINIMAL1=`$ECHO "$JVM_VARIANTS" | $SED -e '/,minimal1,/!s/.*/false/g' -e '/,minimal1,/s/.*/true/g'`
14450   JVM_VARIANT_KERNEL=`$ECHO "$JVM_VARIANTS" | $SED -e '/,kernel,/!s/.*/false/g' -e '/,kernel,/s/.*/true/g'`
14451   JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'`
14452   JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'`
14453   JVM_VARIANT_CORE=`$ECHO "$JVM_VARIANTS" | $SED -e '/,core,/!s/.*/false/g' -e '/,core,/s/.*/true/g'`
14454 
14455   if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14456     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14457       as_fn_error $? "You cannot build a client JVM for a 64-bit machine." "$LINENO" 5
14458     fi
14459   fi
14460   if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14461     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14462       as_fn_error $? "You cannot build a kernel JVM for a 64-bit machine." "$LINENO" 5
14463     fi
14464   fi
14465   if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14466     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14467       as_fn_error $? "You cannot build a minimal JVM for a 64-bit machine." "$LINENO" 5
14468     fi
14469   fi
14470 
14471   # Replace the commas with AND for use in the build directory name.
14472   ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/g'`
14473   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/'`
14474   if test "x$COUNT_VARIANTS" != "x,1"; then
14475     BUILDING_MULTIPLE_JVM_VARIANTS=yes
14476   else
14477     BUILDING_MULTIPLE_JVM_VARIANTS=no
14478   fi
14479 
14480 
14481 
14482 
14483 
14484 
14485 
14486 
14487 
14488 
14489   INCLUDE_SA=true
14490   if test "x$JVM_VARIANT_ZERO" = xtrue ; then
14491     INCLUDE_SA=false
14492   fi
14493   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue ; then
14494     INCLUDE_SA=false
14495   fi
14496   if test "x$VAR_CPU" = xppc64 ; then
14497     INCLUDE_SA=false
14498   fi
14499 
14500 
14501   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
14502     MACOSX_UNIVERSAL="true"
14503   fi
14504 
14505 
14506 
14507 
14508   ###############################################################################
14509   #
14510   # Set the debug level
14511   #    release: no debug information, all optimizations, no asserts.
14512   #    optimized: no debug information, all optimizations, no asserts, HotSpot target is 'optimized'.
14513   #    fastdebug: debug information (-g), all optimizations, all asserts
14514   #    slowdebug: debug information (-g), no optimizations, all asserts
14515   #
14516   DEBUG_LEVEL="release"
14517   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
14518 $as_echo_n "checking which debug level to use... " >&6; }
14519   # Check whether --enable-debug was given.
14520 if test "${enable_debug+set}" = set; then :
14521   enableval=$enable_debug;
14522         ENABLE_DEBUG="${enableval}"
14523         DEBUG_LEVEL="fastdebug"
14524 
14525 else
14526   ENABLE_DEBUG="no"
14527 fi
14528 
14529 
14530 
14531 # Check whether --with-debug-level was given.
14532 if test "${with_debug_level+set}" = set; then :
14533   withval=$with_debug_level;
14534         DEBUG_LEVEL="${withval}"
14535         if test "x$ENABLE_DEBUG" = xyes; then
14536           as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
14537         fi
14538 
14539 fi
14540 
14541   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
14542 $as_echo "$DEBUG_LEVEL" >&6; }
14543 
14544   if test "x$DEBUG_LEVEL" != xrelease && \
14545       test "x$DEBUG_LEVEL" != xoptimized && \
14546       test "x$DEBUG_LEVEL" != xfastdebug && \
14547       test "x$DEBUG_LEVEL" != xslowdebug; then
14548     as_fn_error $? "Allowed debug levels are: release, fastdebug and slowdebug" "$LINENO" 5
14549   fi
14550 
14551 
14552   ###############################################################################
14553   #
14554   # Setup legacy vars/targets and new vars to deal with different debug levels.
14555   #
14556 
14557   case $DEBUG_LEVEL in
14558     release )
14559       VARIANT="OPT"
14560       FASTDEBUG="false"
14561       DEBUG_CLASSFILES="false"
14562       BUILD_VARIANT_RELEASE=""
14563       HOTSPOT_DEBUG_LEVEL="product"
14564       HOTSPOT_EXPORT="product"
14565       ;;
14566     fastdebug )
14567       VARIANT="DBG"
14568       FASTDEBUG="true"
14569       DEBUG_CLASSFILES="true"
14570       BUILD_VARIANT_RELEASE="-fastdebug"
14571       HOTSPOT_DEBUG_LEVEL="fastdebug"
14572       HOTSPOT_EXPORT="fastdebug"
14573       ;;
14574     slowdebug )
14575       VARIANT="DBG"
14576       FASTDEBUG="false"
14577       DEBUG_CLASSFILES="true"
14578       BUILD_VARIANT_RELEASE="-debug"
14579       HOTSPOT_DEBUG_LEVEL="jvmg"
14580       HOTSPOT_EXPORT="debug"
14581       ;;
14582     optimized )
14583       VARIANT="OPT"
14584       FASTDEBUG="false"
14585       DEBUG_CLASSFILES="false"
14586       BUILD_VARIANT_RELEASE="-optimized"
14587       HOTSPOT_DEBUG_LEVEL="optimized"
14588       HOTSPOT_EXPORT="optimized"
14589       ;;
14590   esac
14591 
14592   # The debug level 'optimized' is a little special because it is currently only
14593   # applicable to the HotSpot build where it means to build a completely
14594   # optimized version of the VM without any debugging code (like for the
14595   # 'release' debug level which is called 'product' in the HotSpot build) but
14596   # with the exception that it can contain additional code which is otherwise
14597   # protected by '#ifndef PRODUCT' macros. These 'optimized' builds are used to
14598   # test new and/or experimental features which are not intended for customer
14599   # shipment. Because these new features need to be tested and benchmarked in
14600   # real world scenarios, we want to build the containing JDK at the 'release'
14601   # debug level.
14602   if test "x$DEBUG_LEVEL" = xoptimized; then
14603     DEBUG_LEVEL="release"
14604   fi
14605 
14606   #####
14607   # Generate the legacy makefile targets for hotspot.
14608   # The hotspot api for selecting the build artifacts, really, needs to be improved.
14609   # JDK-7195896 will fix this on the hotspot side by using the JVM_VARIANT_* variables to
14610   # determine what needs to be built. All we will need to set here is all_product, all_fastdebug etc
14611   # But until then ...
14612   HOTSPOT_TARGET=""
14613 
14614   if test "x$JVM_VARIANT_SERVER" = xtrue; then
14615     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL} "
14616   fi
14617 
14618   if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14619     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}1 "
14620   fi
14621 
14622   if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14623     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}minimal1 "
14624   fi
14625 
14626   if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14627     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}kernel "
14628   fi
14629 
14630   if test "x$JVM_VARIANT_ZERO" = xtrue; then
14631     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}zero "
14632   fi
14633 
14634   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
14635     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}shark "
14636   fi
14637 
14638   if test "x$JVM_VARIANT_CORE" = xtrue; then
14639     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}core "
14640   fi
14641 
14642   HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT"
14643 
14644   # On Macosx universal binaries are produced, but they only contain
14645   # 64 bit intel. This invalidates control of which jvms are built
14646   # from configure, but only server is valid anyway. Fix this
14647   # when hotspot makefiles are rewritten.
14648   if test "x$MACOSX_UNIVERSAL" = xtrue; then
14649     HOTSPOT_TARGET=universal_${HOTSPOT_EXPORT}
14650   fi
14651 
14652   #####
14653 
14654 
14655 
14656 
14657 
14658 
14659 
14660 
14661 # With basic setup done, call the custom early hook.
14662 
14663 
14664 # Check if we have devkits, extra paths or sysroot set.
14665 
14666 
14667 # Check whether --with-devkit was given.
14668 if test "${with_devkit+set}" = set; then :
14669   withval=$with_devkit;
14670 
14671   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14672 
14673   # Input might be given as Windows format, start by converting to
14674   # unix format.
14675   path="$with_devkit"
14676   new_path=`$CYGPATH -u "$path"`
14677 
14678   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14679   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14680   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14681   # "foo.exe" is OK but "foo" is an error.
14682   #
14683   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14684   # It is also a way to make sure we got the proper file name for the real test later on.
14685   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14686   if test "x$test_shortpath" = x; then
14687     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14688 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14689     as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
14690   fi
14691 
14692   # Call helper function which possibly converts this using DOS-style short mode.
14693   # If so, the updated path is stored in $new_path.
14694 
14695   input_path="$new_path"
14696   # Check if we need to convert this using DOS-style short mode. If the path
14697   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14698   # take no chances and rewrite it.
14699   # Note: m4 eats our [], so we need to use [ and ] instead.
14700   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14701   if test "x$has_forbidden_chars" != x; then
14702     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14703     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14704     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14705     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14706       # Going to short mode and back again did indeed matter. Since short mode is
14707       # case insensitive, let's make it lowercase to improve readability.
14708       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14709       # Now convert it back to Unix-stile (cygpath)
14710       input_path=`$CYGPATH -u "$shortmode_path"`
14711       new_path="$input_path"
14712     fi
14713   fi
14714 
14715   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14716   if test "x$test_cygdrive_prefix" = x; then
14717     # As a simple fix, exclude /usr/bin since it's not a real path.
14718     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14719       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14720       # a path prefixed by /cygdrive for fixpath to work.
14721       new_path="$CYGWIN_ROOT_PATH$input_path"
14722     fi
14723   fi
14724 
14725 
14726   if test "x$path" != "x$new_path"; then
14727     with_devkit="$new_path"
14728     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14729 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14730   fi
14731 
14732   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14733 
14734   path="$with_devkit"
14735   has_colon=`$ECHO $path | $GREP ^.:`
14736   new_path="$path"
14737   if test "x$has_colon" = x; then
14738     # Not in mixed or Windows style, start by that.
14739     new_path=`cmd //c echo $path`
14740   fi
14741 
14742 
14743   input_path="$new_path"
14744   # Check if we need to convert this using DOS-style short mode. If the path
14745   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14746   # take no chances and rewrite it.
14747   # Note: m4 eats our [], so we need to use [ and ] instead.
14748   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14749   if test "x$has_forbidden_chars" != x; then
14750     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14751     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14752   fi
14753 
14754 
14755   windows_path="$new_path"
14756   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14757     unix_path=`$CYGPATH -u "$windows_path"`
14758     new_path="$unix_path"
14759   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14760     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14761     new_path="$unix_path"
14762   fi
14763 
14764   if test "x$path" != "x$new_path"; then
14765     with_devkit="$new_path"
14766     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14767 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14768   fi
14769 
14770   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14771   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14772 
14773   else
14774     # We're on a posix platform. Hooray! :)
14775     path="$with_devkit"
14776     has_space=`$ECHO "$path" | $GREP " "`
14777     if test "x$has_space" != x; then
14778       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14779 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14780       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14781     fi
14782 
14783     # Use eval to expand a potential ~
14784     eval path="$path"
14785     if test ! -f "$path" && test ! -d "$path"; then
14786       as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
14787     fi
14788 
14789     with_devkit="`cd "$path"; $THEPWDCMD -L`"
14790   fi
14791 
14792         DEVKIT_ROOT="$with_devkit"
14793         # Check for a meta data info file in the root of the devkit
14794         if test -f "$DEVKIT_ROOT/devkit.info"; then
14795           # This potentially sets the following:
14796           # DEVKIT_NAME: A descriptive name of the devkit
14797           # DEVKIT_TOOLCHAIN_PATH: Corresponds to --with-toolchain-path
14798           # DEVKIT_EXTRA_PATH: Corresponds to --with-extra-path
14799           # DEVKIT_SYSROOT: Corresponds to --with-sysroot
14800           . $DEVKIT_ROOT/devkit.info
14801         fi
14802 
14803         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
14804 $as_echo_n "checking for devkit... " >&6; }
14805         if test "x$DEVKIT_NAME" != x; then
14806           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
14807 $as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
14808         else
14809           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
14810 $as_echo "$DEVKIT_ROOT" >&6; }
14811         fi
14812 
14813         if test "x$DEVKIT_EXTRA_PATH" != x; then
14814 
14815   if test "x$DEVKIT_EXTRA_PATH" != x; then
14816     if test "x$EXTRA_PATH" = x; then
14817       EXTRA_PATH="$DEVKIT_EXTRA_PATH"
14818     else
14819       EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH"
14820     fi
14821   fi
14822 
14823         fi
14824 
14825         # Fallback default of just /bin if DEVKIT_PATH is not defined
14826         if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
14827           DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin"
14828         fi
14829 
14830   if test "x$DEVKIT_TOOLCHAIN_PATH" != x; then
14831     if test "x$TOOLCHAIN_PATH" = x; then
14832       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH"
14833     else
14834       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH:$TOOLCHAIN_PATH"
14835     fi
14836   fi
14837 
14838 
14839         # If DEVKIT_SYSROOT is set, use that, otherwise try a couple of known
14840         # places for backwards compatiblity.
14841         if test "x$DEVKIT_SYSROOT" != x; then
14842           SYSROOT="$DEVKIT_SYSROOT"
14843         elif test -d "$DEVKIT_ROOT/$host_alias/libc"; then
14844           SYSROOT="$DEVKIT_ROOT/$host_alias/libc"
14845         elif test -d "$DEVKIT_ROOT/$host/sys-root"; then
14846           SYSROOT="$DEVKIT_ROOT/$host/sys-root"
14847         fi
14848 
14849 
14850 fi
14851 
14852 
14853   # You can force the sysroot if the sysroot encoded into the compiler tools
14854   # is not correct.
14855 
14856 # Check whether --with-sys-root was given.
14857 if test "${with_sys_root+set}" = set; then :
14858   withval=$with_sys_root; SYSROOT=$with_sys_root
14859 
14860 fi
14861 
14862 
14863 
14864 # Check whether --with-sysroot was given.
14865 if test "${with_sysroot+set}" = set; then :
14866   withval=$with_sysroot; SYSROOT=$with_sysroot
14867 
14868 fi
14869 
14870 
14871 
14872 # Check whether --with-tools-dir was given.
14873 if test "${with_tools_dir+set}" = set; then :
14874   withval=$with_tools_dir;
14875   if test "x$with_tools_dir" != x; then
14876     if test "x$TOOLCHAIN_PATH" = x; then
14877       TOOLCHAIN_PATH="$with_tools_dir"
14878     else
14879       TOOLCHAIN_PATH="$with_tools_dir:$TOOLCHAIN_PATH"
14880     fi
14881   fi
14882 
14883 
14884 fi
14885 
14886 
14887 
14888 # Check whether --with-toolchain-path was given.
14889 if test "${with_toolchain_path+set}" = set; then :
14890   withval=$with_toolchain_path;
14891   if test "x$with_toolchain_path" != x; then
14892     if test "x$TOOLCHAIN_PATH" = x; then
14893       TOOLCHAIN_PATH="$with_toolchain_path"
14894     else
14895       TOOLCHAIN_PATH="$with_toolchain_path:$TOOLCHAIN_PATH"
14896     fi
14897   fi
14898 
14899 
14900 fi
14901 
14902 
14903 
14904 # Check whether --with-extra-path was given.
14905 if test "${with_extra_path+set}" = set; then :
14906   withval=$with_extra_path;
14907   if test "x$with_extra_path" != x; then
14908     if test "x$EXTRA_PATH" = x; then
14909       EXTRA_PATH="$with_extra_path"
14910     else
14911       EXTRA_PATH="$with_extra_path:$EXTRA_PATH"
14912     fi
14913   fi
14914 
14915 
14916 fi
14917 
14918 
14919   # Prepend the extra path to the global path
14920 
14921   if test "x$EXTRA_PATH" != x; then
14922     if test "x$PATH" = x; then
14923       PATH="$EXTRA_PATH"
14924     else
14925       PATH="$EXTRA_PATH:$PATH"
14926     fi
14927   fi
14928 
14929 
14930   if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
14931     # Add extra search paths on solaris for utilities like ar and as etc...
14932     PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin"
14933   fi
14934 
14935   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
14936 $as_echo_n "checking for sysroot... " >&6; }
14937   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
14938 $as_echo "$SYSROOT" >&6; }
14939   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
14940 $as_echo_n "checking for toolchain path... " >&6; }
14941   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
14942 $as_echo "$TOOLCHAIN_PATH" >&6; }
14943   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
14944 $as_echo_n "checking for extra path... " >&6; }
14945   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
14946 $as_echo "$EXTRA_PATH" >&6; }
14947 
14948 
14949 # To properly create a configuration name, we need to have the OpenJDK target
14950 # and options (variants and debug level) parsed.
14951 
14952 
14953 
14954 # Check whether --with-conf-name was given.
14955 if test "${with_conf_name+set}" = set; then :
14956   withval=$with_conf_name;  CONF_NAME=${with_conf_name}
14957 fi
14958 
14959 
14960   # Test from where we are running configure, in or outside of src root.
14961   { $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
14962 $as_echo_n "checking where to store configuration... " >&6; }
14963   if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
14964       || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
14965       || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
14966     # We are running configure from the src root.
14967     # Create a default ./build/target-variant-debuglevel output root.
14968     if test "x${CONF_NAME}" = x; then
14969       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
14970 $as_echo "in default location" >&6; }
14971       CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}"
14972     else
14973       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
14974 $as_echo "in build directory with custom name" >&6; }
14975     fi
14976     OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
14977     $MKDIR -p "$OUTPUT_ROOT"
14978     if test ! -d "$OUTPUT_ROOT"; then
14979       as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
14980     fi
14981   else
14982     # We are running configure from outside of the src dir.
14983     # Then use the current directory as output dir!
14984     # If configuration is situated in normal build directory, just use the build
14985     # directory name as configuration name, otherwise use the complete path.
14986     if test "x${CONF_NAME}" = x; then
14987       CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
14988     fi
14989     OUTPUT_ROOT="$CURDIR"
14990     { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
14991 $as_echo "in current directory" >&6; }
14992 
14993     # WARNING: This might be a bad thing to do. You need to be sure you want to
14994     # have a configuration in this directory. Do some sanity checks!
14995 
14996     if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
14997       # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
14998       # other files
14999       files_present=`$LS $OUTPUT_ROOT`
15000       # Configure has already touched config.log and confdefs.h in the current dir when this check
15001       # is performed.
15002       filtered_files=`$ECHO "$files_present" | $SED -e 's/config.log//g' -e 's/confdefs.h//g' -e 's/ //g' \
15003       | $TR -d '\n'`
15004       if test "x$filtered_files" != x; then
15005         { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
15006 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
15007         { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
15008 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
15009         { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
15010 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
15011         { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
15012 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
15013         { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
15014 $as_echo "$as_me: seriously mess up just about everything." >&6;}
15015         { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
15016 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
15017         { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
15018 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
15019         as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
15020       fi
15021     fi
15022   fi
15023   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
15024 $as_echo_n "checking what configuration name to use... " >&6; }
15025   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
15026 $as_echo "$CONF_NAME" >&6; }
15027 
15028 
15029   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15030 
15031   # Input might be given as Windows format, start by converting to
15032   # unix format.
15033   path="$OUTPUT_ROOT"
15034   new_path=`$CYGPATH -u "$path"`
15035 
15036   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15037   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15038   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15039   # "foo.exe" is OK but "foo" is an error.
15040   #
15041   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15042   # It is also a way to make sure we got the proper file name for the real test later on.
15043   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15044   if test "x$test_shortpath" = x; then
15045     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
15046 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
15047     as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
15048   fi
15049 
15050   # Call helper function which possibly converts this using DOS-style short mode.
15051   # If so, the updated path is stored in $new_path.
15052 
15053   input_path="$new_path"
15054   # Check if we need to convert this using DOS-style short mode. If the path
15055   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15056   # take no chances and rewrite it.
15057   # Note: m4 eats our [], so we need to use [ and ] instead.
15058   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15059   if test "x$has_forbidden_chars" != x; then
15060     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15061     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15062     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15063     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15064       # Going to short mode and back again did indeed matter. Since short mode is
15065       # case insensitive, let's make it lowercase to improve readability.
15066       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15067       # Now convert it back to Unix-stile (cygpath)
15068       input_path=`$CYGPATH -u "$shortmode_path"`
15069       new_path="$input_path"
15070     fi
15071   fi
15072 
15073   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15074   if test "x$test_cygdrive_prefix" = x; then
15075     # As a simple fix, exclude /usr/bin since it's not a real path.
15076     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15077       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15078       # a path prefixed by /cygdrive for fixpath to work.
15079       new_path="$CYGWIN_ROOT_PATH$input_path"
15080     fi
15081   fi
15082 
15083 
15084   if test "x$path" != "x$new_path"; then
15085     OUTPUT_ROOT="$new_path"
15086     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15087 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15088   fi
15089 
15090   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15091 
15092   path="$OUTPUT_ROOT"
15093   has_colon=`$ECHO $path | $GREP ^.:`
15094   new_path="$path"
15095   if test "x$has_colon" = x; then
15096     # Not in mixed or Windows style, start by that.
15097     new_path=`cmd //c echo $path`
15098   fi
15099 
15100 
15101   input_path="$new_path"
15102   # Check if we need to convert this using DOS-style short mode. If the path
15103   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15104   # take no chances and rewrite it.
15105   # Note: m4 eats our [], so we need to use [ and ] instead.
15106   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15107   if test "x$has_forbidden_chars" != x; then
15108     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15109     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15110   fi
15111 
15112 
15113   windows_path="$new_path"
15114   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15115     unix_path=`$CYGPATH -u "$windows_path"`
15116     new_path="$unix_path"
15117   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15118     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15119     new_path="$unix_path"
15120   fi
15121 
15122   if test "x$path" != "x$new_path"; then
15123     OUTPUT_ROOT="$new_path"
15124     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15125 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15126   fi
15127 
15128   # Save the first 10 bytes of this path to the storage, so fixpath can work.
15129   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15130 
15131   else
15132     # We're on a posix platform. Hooray! :)
15133     path="$OUTPUT_ROOT"
15134     has_space=`$ECHO "$path" | $GREP " "`
15135     if test "x$has_space" != x; then
15136       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
15137 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
15138       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15139     fi
15140 
15141     # Use eval to expand a potential ~
15142     eval path="$path"
15143     if test ! -f "$path" && test ! -d "$path"; then
15144       as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
15145     fi
15146 
15147     OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
15148   fi
15149 
15150 
15151   SPEC=$OUTPUT_ROOT/spec.gmk
15152 
15153   CONF_NAME=$CONF_NAME
15154 
15155   OUTPUT_ROOT=$OUTPUT_ROOT
15156 
15157 
15158   # Most of the probed defines are put into config.h
15159   ac_config_headers="$ac_config_headers $OUTPUT_ROOT/config.h:$AUTOCONF_DIR/config.h.in"
15160 
15161   # The spec.gmk file contains all variables for the make system.
15162   ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
15163 
15164   # The hotspot-spec.gmk file contains legacy variables for the hotspot make system.
15165   ac_config_files="$ac_config_files $OUTPUT_ROOT/hotspot-spec.gmk:$AUTOCONF_DIR/hotspot-spec.gmk.in"
15166 
15167   # The bootcycle-spec.gmk file contains support for boot cycle builds.
15168   ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
15169 
15170   # The compare.sh is used to compare the build output to other builds.
15171   ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
15172 
15173   # Spec.sh is currently used by compare-objects.sh
15174   ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.sh:$AUTOCONF_DIR/spec.sh.in"
15175 
15176   # The generated Makefile knows where the spec.gmk is and where the source is.
15177   # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
15178   # which will look for generated configurations
15179   ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
15180 
15181 
15182 
15183 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
15184 
15185   for ac_prog in apt-get yum port pkgutil pkgadd
15186 do
15187   # Extract the first word of "$ac_prog", so it can be a program name with args.
15188 set dummy $ac_prog; ac_word=$2
15189 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15190 $as_echo_n "checking for $ac_word... " >&6; }
15191 if ${ac_cv_prog_PKGHANDLER+:} false; then :
15192   $as_echo_n "(cached) " >&6
15193 else
15194   if test -n "$PKGHANDLER"; then
15195   ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
15196 else
15197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15198 for as_dir in $PATH
15199 do
15200   IFS=$as_save_IFS
15201   test -z "$as_dir" && as_dir=.
15202     for ac_exec_ext in '' $ac_executable_extensions; do
15203   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15204     ac_cv_prog_PKGHANDLER="$ac_prog"
15205     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15206     break 2
15207   fi
15208 done
15209   done
15210 IFS=$as_save_IFS
15211 
15212 fi
15213 fi
15214 PKGHANDLER=$ac_cv_prog_PKGHANDLER
15215 if test -n "$PKGHANDLER"; then
15216   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
15217 $as_echo "$PKGHANDLER" >&6; }
15218 else
15219   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15220 $as_echo "no" >&6; }
15221 fi
15222 
15223 
15224   test -n "$PKGHANDLER" && break
15225 done
15226 
15227 
15228 
15229 # Setup tools that requires more complex handling, or that is not needed by the configure script.
15230 
15231 
15232   # We need to find a recent version of GNU make. Especially on Solaris, this can be tricky.
15233   if test "x$MAKE" != x; then
15234     # User has supplied a make, test it.
15235     if test ! -f "$MAKE"; then
15236       as_fn_error $? "The specified make (by MAKE=$MAKE) is not found." "$LINENO" 5
15237     fi
15238 
15239   MAKE_CANDIDATE=""$MAKE""
15240   DESCRIPTION="user supplied MAKE=$MAKE"
15241   if test "x$MAKE_CANDIDATE" != x; then
15242     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15243 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15244     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15245     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15246     if test "x$IS_GNU_MAKE" = x; then
15247       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15248 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15249     else
15250       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15251       if test "x$IS_MODERN_MAKE" = x; then
15252         { $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
15253 $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;}
15254       else
15255         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15256           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15257             MAKE_EXPECTED_ENV='cygwin'
15258           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15259             MAKE_EXPECTED_ENV='msys'
15260           else
15261             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15262           fi
15263           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15264           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15265         else
15266           # Not relevant for non-Windows
15267           IS_MAKE_CORRECT_ENV=true
15268         fi
15269         if test "x$IS_MAKE_CORRECT_ENV" = x; then
15270           { $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
15271 $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;}
15272         else
15273           FOUND_MAKE=$MAKE_CANDIDATE
15274 
15275   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15276 
15277   # First separate the path from the arguments. This will split at the first
15278   # space.
15279   complete="$FOUND_MAKE"
15280   path="${complete%% *}"
15281   tmp="$complete EOL"
15282   arguments="${tmp#* }"
15283 
15284   # Input might be given as Windows format, start by converting to
15285   # unix format.
15286   new_path=`$CYGPATH -u "$path"`
15287 
15288   # Now try to locate executable using which
15289   new_path=`$WHICH "$new_path" 2> /dev/null`
15290   # bat and cmd files are not always considered executable in cygwin causing which
15291   # to not find them
15292   if test "x$new_path" = x \
15293       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15294       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15295     new_path=`$CYGPATH -u "$path"`
15296   fi
15297   if test "x$new_path" = x; then
15298     # Oops. Which didn't find the executable.
15299     # The splitting of arguments from the executable at a space might have been incorrect,
15300     # since paths with space are more likely in Windows. Give it another try with the whole
15301     # argument.
15302     path="$complete"
15303     arguments="EOL"
15304     new_path=`$CYGPATH -u "$path"`
15305     new_path=`$WHICH "$new_path" 2> /dev/null`
15306     # bat and cmd files are not always considered executable in cygwin causing which
15307     # to not find them
15308     if test "x$new_path" = x \
15309         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15310         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15311       new_path=`$CYGPATH -u "$path"`
15312     fi
15313     if test "x$new_path" = x; then
15314       # It's still not found. Now this is an unrecoverable error.
15315       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15316 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15317       has_space=`$ECHO "$complete" | $GREP " "`
15318       if test "x$has_space" != x; then
15319         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15320 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15321       fi
15322       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15323     fi
15324   fi
15325 
15326   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15327   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15328   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15329   # "foo.exe" is OK but "foo" is an error.
15330   #
15331   # This test is therefore slightly more accurate than "test -f" to check for file presence.
15332   # It is also a way to make sure we got the proper file name for the real test later on.
15333   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15334   if test "x$test_shortpath" = x; then
15335     # Short path failed, file does not exist as specified.
15336     # Try adding .exe or .cmd
15337     if test -f "${new_path}.exe"; then
15338       input_to_shortpath="${new_path}.exe"
15339     elif test -f "${new_path}.cmd"; then
15340       input_to_shortpath="${new_path}.cmd"
15341     else
15342       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15343 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15344       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15345 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15346       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15347     fi
15348   else
15349     input_to_shortpath="$new_path"
15350   fi
15351 
15352   # Call helper function which possibly converts this using DOS-style short mode.
15353   # If so, the updated path is stored in $new_path.
15354   new_path="$input_to_shortpath"
15355 
15356   input_path="$input_to_shortpath"
15357   # Check if we need to convert this using DOS-style short mode. If the path
15358   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15359   # take no chances and rewrite it.
15360   # Note: m4 eats our [], so we need to use [ and ] instead.
15361   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15362   if test "x$has_forbidden_chars" != x; then
15363     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15364     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15365     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15366     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15367       # Going to short mode and back again did indeed matter. Since short mode is
15368       # case insensitive, let's make it lowercase to improve readability.
15369       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15370       # Now convert it back to Unix-stile (cygpath)
15371       input_path=`$CYGPATH -u "$shortmode_path"`
15372       new_path="$input_path"
15373     fi
15374   fi
15375 
15376   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15377   if test "x$test_cygdrive_prefix" = x; then
15378     # As a simple fix, exclude /usr/bin since it's not a real path.
15379     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15380       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15381       # a path prefixed by /cygdrive for fixpath to work.
15382       new_path="$CYGWIN_ROOT_PATH$input_path"
15383     fi
15384   fi
15385 
15386   # remove trailing .exe if any
15387   new_path="${new_path/%.exe/}"
15388 
15389   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15390 
15391   # First separate the path from the arguments. This will split at the first
15392   # space.
15393   complete="$FOUND_MAKE"
15394   path="${complete%% *}"
15395   tmp="$complete EOL"
15396   arguments="${tmp#* }"
15397 
15398   # Input might be given as Windows format, start by converting to
15399   # unix format.
15400   new_path="$path"
15401 
15402   windows_path="$new_path"
15403   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15404     unix_path=`$CYGPATH -u "$windows_path"`
15405     new_path="$unix_path"
15406   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15407     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15408     new_path="$unix_path"
15409   fi
15410 
15411 
15412   # Now try to locate executable using which
15413   new_path=`$WHICH "$new_path" 2> /dev/null`
15414 
15415   if test "x$new_path" = x; then
15416     # Oops. Which didn't find the executable.
15417     # The splitting of arguments from the executable at a space might have been incorrect,
15418     # since paths with space are more likely in Windows. Give it another try with the whole
15419     # argument.
15420     path="$complete"
15421     arguments="EOL"
15422     new_path="$path"
15423 
15424   windows_path="$new_path"
15425   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15426     unix_path=`$CYGPATH -u "$windows_path"`
15427     new_path="$unix_path"
15428   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15429     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15430     new_path="$unix_path"
15431   fi
15432 
15433 
15434     new_path=`$WHICH "$new_path" 2> /dev/null`
15435 
15436     if test "x$new_path" = x; then
15437       # It's still not found. Now this is an unrecoverable error.
15438       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15439 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15440       has_space=`$ECHO "$complete" | $GREP " "`
15441       if test "x$has_space" != x; then
15442         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15443 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15444       fi
15445       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15446     fi
15447   fi
15448 
15449   # Now new_path has a complete unix path to the binary
15450   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15451     # Keep paths in /bin as-is, but remove trailing .exe if any
15452     new_path="${new_path/%.exe/}"
15453     # Do not save /bin paths to all_fixpath_prefixes!
15454   else
15455     # Not in mixed or Windows style, start by that.
15456     new_path=`cmd //c echo $new_path`
15457 
15458   input_path="$new_path"
15459   # Check if we need to convert this using DOS-style short mode. If the path
15460   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15461   # take no chances and rewrite it.
15462   # Note: m4 eats our [], so we need to use [ and ] instead.
15463   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15464   if test "x$has_forbidden_chars" != x; then
15465     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15466     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15467   fi
15468 
15469     # Output is in $new_path
15470 
15471   windows_path="$new_path"
15472   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15473     unix_path=`$CYGPATH -u "$windows_path"`
15474     new_path="$unix_path"
15475   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15476     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15477     new_path="$unix_path"
15478   fi
15479 
15480     # remove trailing .exe if any
15481     new_path="${new_path/%.exe/}"
15482 
15483     # Save the first 10 bytes of this path to the storage, so fixpath can work.
15484     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15485   fi
15486 
15487   else
15488     # We're on a posix platform. Hooray! :)
15489     # First separate the path from the arguments. This will split at the first
15490     # space.
15491     complete="$FOUND_MAKE"
15492     path="${complete%% *}"
15493     tmp="$complete EOL"
15494     arguments="${tmp#* }"
15495 
15496     # Cannot rely on the command "which" here since it doesn't always work.
15497     is_absolute_path=`$ECHO "$path" | $GREP ^/`
15498     if test -z "$is_absolute_path"; then
15499       # Path to executable is not absolute. Find it.
15500       IFS_save="$IFS"
15501       IFS=:
15502       for p in $PATH; do
15503         if test -f "$p/$path" && test -x "$p/$path"; then
15504           new_path="$p/$path"
15505           break
15506         fi
15507       done
15508       IFS="$IFS_save"
15509     else
15510       # This is an absolute path, we can use it without further modifications.
15511       new_path="$path"
15512     fi
15513 
15514     if test "x$new_path" = x; then
15515       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15516 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15517       has_space=`$ECHO "$complete" | $GREP " "`
15518       if test "x$has_space" != x; then
15519         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
15520 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
15521       fi
15522       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15523     fi
15524   fi
15525 
15526   # Now join together the path and the arguments once again
15527   if test "x$arguments" != xEOL; then
15528     new_complete="$new_path ${arguments% *}"
15529   else
15530     new_complete="$new_path"
15531   fi
15532 
15533   if test "x$complete" != "x$new_complete"; then
15534     FOUND_MAKE="$new_complete"
15535     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
15536 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
15537   fi
15538 
15539         fi
15540       fi
15541     fi
15542   fi
15543 
15544     if test "x$FOUND_MAKE" = x; then
15545       as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make 3.81 or newer." "$LINENO" 5
15546     fi
15547   else
15548     # Try our hardest to locate a correct version of GNU make
15549     for ac_prog in gmake
15550 do
15551   # Extract the first word of "$ac_prog", so it can be a program name with args.
15552 set dummy $ac_prog; ac_word=$2
15553 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15554 $as_echo_n "checking for $ac_word... " >&6; }
15555 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
15556   $as_echo_n "(cached) " >&6
15557 else
15558   case $CHECK_GMAKE in
15559   [\\/]* | ?:[\\/]*)
15560   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
15561   ;;
15562   *)
15563   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15564 for as_dir in $PATH
15565 do
15566   IFS=$as_save_IFS
15567   test -z "$as_dir" && as_dir=.
15568     for ac_exec_ext in '' $ac_executable_extensions; do
15569   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15570     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
15571     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15572     break 2
15573   fi
15574 done
15575   done
15576 IFS=$as_save_IFS
15577 
15578   ;;
15579 esac
15580 fi
15581 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
15582 if test -n "$CHECK_GMAKE"; then
15583   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
15584 $as_echo "$CHECK_GMAKE" >&6; }
15585 else
15586   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15587 $as_echo "no" >&6; }
15588 fi
15589 
15590 
15591   test -n "$CHECK_GMAKE" && break
15592 done
15593 
15594 
15595   MAKE_CANDIDATE=""$CHECK_GMAKE""
15596   DESCRIPTION="gmake in PATH"
15597   if test "x$MAKE_CANDIDATE" != x; then
15598     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15599 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15600     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15601     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15602     if test "x$IS_GNU_MAKE" = x; then
15603       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15604 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15605     else
15606       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15607       if test "x$IS_MODERN_MAKE" = x; then
15608         { $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
15609 $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;}
15610       else
15611         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15612           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15613             MAKE_EXPECTED_ENV='cygwin'
15614           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15615             MAKE_EXPECTED_ENV='msys'
15616           else
15617             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15618           fi
15619           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15620           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15621         else
15622           # Not relevant for non-Windows
15623           IS_MAKE_CORRECT_ENV=true
15624         fi
15625         if test "x$IS_MAKE_CORRECT_ENV" = x; then
15626           { $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
15627 $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;}
15628         else
15629           FOUND_MAKE=$MAKE_CANDIDATE
15630 
15631   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15632 
15633   # First separate the path from the arguments. This will split at the first
15634   # space.
15635   complete="$FOUND_MAKE"
15636   path="${complete%% *}"
15637   tmp="$complete EOL"
15638   arguments="${tmp#* }"
15639 
15640   # Input might be given as Windows format, start by converting to
15641   # unix format.
15642   new_path=`$CYGPATH -u "$path"`
15643 
15644   # Now try to locate executable using which
15645   new_path=`$WHICH "$new_path" 2> /dev/null`
15646   # bat and cmd files are not always considered executable in cygwin causing which
15647   # to not find them
15648   if test "x$new_path" = x \
15649       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15650       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15651     new_path=`$CYGPATH -u "$path"`
15652   fi
15653   if test "x$new_path" = x; then
15654     # Oops. Which didn't find the executable.
15655     # The splitting of arguments from the executable at a space might have been incorrect,
15656     # since paths with space are more likely in Windows. Give it another try with the whole
15657     # argument.
15658     path="$complete"
15659     arguments="EOL"
15660     new_path=`$CYGPATH -u "$path"`
15661     new_path=`$WHICH "$new_path" 2> /dev/null`
15662     # bat and cmd files are not always considered executable in cygwin causing which
15663     # to not find them
15664     if test "x$new_path" = x \
15665         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15666         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15667       new_path=`$CYGPATH -u "$path"`
15668     fi
15669     if test "x$new_path" = x; then
15670       # It's still not found. Now this is an unrecoverable error.
15671       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15672 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15673       has_space=`$ECHO "$complete" | $GREP " "`
15674       if test "x$has_space" != x; then
15675         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15676 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15677       fi
15678       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15679     fi
15680   fi
15681 
15682   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15683   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15684   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15685   # "foo.exe" is OK but "foo" is an error.
15686   #
15687   # This test is therefore slightly more accurate than "test -f" to check for file presence.
15688   # It is also a way to make sure we got the proper file name for the real test later on.
15689   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15690   if test "x$test_shortpath" = x; then
15691     # Short path failed, file does not exist as specified.
15692     # Try adding .exe or .cmd
15693     if test -f "${new_path}.exe"; then
15694       input_to_shortpath="${new_path}.exe"
15695     elif test -f "${new_path}.cmd"; then
15696       input_to_shortpath="${new_path}.cmd"
15697     else
15698       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15699 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15700       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15701 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15702       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15703     fi
15704   else
15705     input_to_shortpath="$new_path"
15706   fi
15707 
15708   # Call helper function which possibly converts this using DOS-style short mode.
15709   # If so, the updated path is stored in $new_path.
15710   new_path="$input_to_shortpath"
15711 
15712   input_path="$input_to_shortpath"
15713   # Check if we need to convert this using DOS-style short mode. If the path
15714   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15715   # take no chances and rewrite it.
15716   # Note: m4 eats our [], so we need to use [ and ] instead.
15717   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15718   if test "x$has_forbidden_chars" != x; then
15719     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15720     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15721     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15722     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15723       # Going to short mode and back again did indeed matter. Since short mode is
15724       # case insensitive, let's make it lowercase to improve readability.
15725       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15726       # Now convert it back to Unix-stile (cygpath)
15727       input_path=`$CYGPATH -u "$shortmode_path"`
15728       new_path="$input_path"
15729     fi
15730   fi
15731 
15732   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15733   if test "x$test_cygdrive_prefix" = x; then
15734     # As a simple fix, exclude /usr/bin since it's not a real path.
15735     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15736       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15737       # a path prefixed by /cygdrive for fixpath to work.
15738       new_path="$CYGWIN_ROOT_PATH$input_path"
15739     fi
15740   fi
15741 
15742   # remove trailing .exe if any
15743   new_path="${new_path/%.exe/}"
15744 
15745   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15746 
15747   # First separate the path from the arguments. This will split at the first
15748   # space.
15749   complete="$FOUND_MAKE"
15750   path="${complete%% *}"
15751   tmp="$complete EOL"
15752   arguments="${tmp#* }"
15753 
15754   # Input might be given as Windows format, start by converting to
15755   # unix format.
15756   new_path="$path"
15757 
15758   windows_path="$new_path"
15759   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15760     unix_path=`$CYGPATH -u "$windows_path"`
15761     new_path="$unix_path"
15762   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15763     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15764     new_path="$unix_path"
15765   fi
15766 
15767 
15768   # Now try to locate executable using which
15769   new_path=`$WHICH "$new_path" 2> /dev/null`
15770 
15771   if test "x$new_path" = x; then
15772     # Oops. Which didn't find the executable.
15773     # The splitting of arguments from the executable at a space might have been incorrect,
15774     # since paths with space are more likely in Windows. Give it another try with the whole
15775     # argument.
15776     path="$complete"
15777     arguments="EOL"
15778     new_path="$path"
15779 
15780   windows_path="$new_path"
15781   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15782     unix_path=`$CYGPATH -u "$windows_path"`
15783     new_path="$unix_path"
15784   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15785     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15786     new_path="$unix_path"
15787   fi
15788 
15789 
15790     new_path=`$WHICH "$new_path" 2> /dev/null`
15791 
15792     if test "x$new_path" = x; then
15793       # It's still not found. Now this is an unrecoverable error.
15794       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15795 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15796       has_space=`$ECHO "$complete" | $GREP " "`
15797       if test "x$has_space" != x; then
15798         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15799 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15800       fi
15801       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15802     fi
15803   fi
15804 
15805   # Now new_path has a complete unix path to the binary
15806   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15807     # Keep paths in /bin as-is, but remove trailing .exe if any
15808     new_path="${new_path/%.exe/}"
15809     # Do not save /bin paths to all_fixpath_prefixes!
15810   else
15811     # Not in mixed or Windows style, start by that.
15812     new_path=`cmd //c echo $new_path`
15813 
15814   input_path="$new_path"
15815   # Check if we need to convert this using DOS-style short mode. If the path
15816   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15817   # take no chances and rewrite it.
15818   # Note: m4 eats our [], so we need to use [ and ] instead.
15819   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15820   if test "x$has_forbidden_chars" != x; then
15821     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15822     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15823   fi
15824 
15825     # Output is in $new_path
15826 
15827   windows_path="$new_path"
15828   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15829     unix_path=`$CYGPATH -u "$windows_path"`
15830     new_path="$unix_path"
15831   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15832     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15833     new_path="$unix_path"
15834   fi
15835 
15836     # remove trailing .exe if any
15837     new_path="${new_path/%.exe/}"
15838 
15839     # Save the first 10 bytes of this path to the storage, so fixpath can work.
15840     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15841   fi
15842 
15843   else
15844     # We're on a posix platform. Hooray! :)
15845     # First separate the path from the arguments. This will split at the first
15846     # space.
15847     complete="$FOUND_MAKE"
15848     path="${complete%% *}"
15849     tmp="$complete EOL"
15850     arguments="${tmp#* }"
15851 
15852     # Cannot rely on the command "which" here since it doesn't always work.
15853     is_absolute_path=`$ECHO "$path" | $GREP ^/`
15854     if test -z "$is_absolute_path"; then
15855       # Path to executable is not absolute. Find it.
15856       IFS_save="$IFS"
15857       IFS=:
15858       for p in $PATH; do
15859         if test -f "$p/$path" && test -x "$p/$path"; then
15860           new_path="$p/$path"
15861           break
15862         fi
15863       done
15864       IFS="$IFS_save"
15865     else
15866       # This is an absolute path, we can use it without further modifications.
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 
15901     if test "x$FOUND_MAKE" = x; then
15902       for ac_prog in make
15903 do
15904   # Extract the first word of "$ac_prog", so it can be a program name with args.
15905 set dummy $ac_prog; ac_word=$2
15906 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15907 $as_echo_n "checking for $ac_word... " >&6; }
15908 if ${ac_cv_path_CHECK_MAKE+:} false; then :
15909   $as_echo_n "(cached) " >&6
15910 else
15911   case $CHECK_MAKE in
15912   [\\/]* | ?:[\\/]*)
15913   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
15914   ;;
15915   *)
15916   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15917 for as_dir in $PATH
15918 do
15919   IFS=$as_save_IFS
15920   test -z "$as_dir" && as_dir=.
15921     for ac_exec_ext in '' $ac_executable_extensions; do
15922   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15923     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
15924     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15925     break 2
15926   fi
15927 done
15928   done
15929 IFS=$as_save_IFS
15930 
15931   ;;
15932 esac
15933 fi
15934 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
15935 if test -n "$CHECK_MAKE"; then
15936   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
15937 $as_echo "$CHECK_MAKE" >&6; }
15938 else
15939   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15940 $as_echo "no" >&6; }
15941 fi
15942 
15943 
15944   test -n "$CHECK_MAKE" && break
15945 done
15946 
15947 
15948   MAKE_CANDIDATE=""$CHECK_MAKE""
15949   DESCRIPTION="make in PATH"
15950   if test "x$MAKE_CANDIDATE" != x; then
15951     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15952 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15953     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15954     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15955     if test "x$IS_GNU_MAKE" = x; then
15956       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15957 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15958     else
15959       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15960       if test "x$IS_MODERN_MAKE" = x; then
15961         { $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
15962 $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;}
15963       else
15964         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15965           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15966             MAKE_EXPECTED_ENV='cygwin'
15967           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15968             MAKE_EXPECTED_ENV='msys'
15969           else
15970             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15971           fi
15972           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15973           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15974         else
15975           # Not relevant for non-Windows
15976           IS_MAKE_CORRECT_ENV=true
15977         fi
15978         if test "x$IS_MAKE_CORRECT_ENV" = x; then
15979           { $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
15980 $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;}
15981         else
15982           FOUND_MAKE=$MAKE_CANDIDATE
15983 
15984   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15985 
15986   # First separate the path from the arguments. This will split at the first
15987   # space.
15988   complete="$FOUND_MAKE"
15989   path="${complete%% *}"
15990   tmp="$complete EOL"
15991   arguments="${tmp#* }"
15992 
15993   # Input might be given as Windows format, start by converting to
15994   # unix format.
15995   new_path=`$CYGPATH -u "$path"`
15996 
15997   # Now try to locate executable using which
15998   new_path=`$WHICH "$new_path" 2> /dev/null`
15999   # bat and cmd files are not always considered executable in cygwin causing which
16000   # to not find them
16001   if test "x$new_path" = x \
16002       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16003       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16004     new_path=`$CYGPATH -u "$path"`
16005   fi
16006   if test "x$new_path" = x; then
16007     # Oops. Which didn't find the executable.
16008     # The splitting of arguments from the executable at a space might have been incorrect,
16009     # since paths with space are more likely in Windows. Give it another try with the whole
16010     # argument.
16011     path="$complete"
16012     arguments="EOL"
16013     new_path=`$CYGPATH -u "$path"`
16014     new_path=`$WHICH "$new_path" 2> /dev/null`
16015     # bat and cmd files are not always considered executable in cygwin causing which
16016     # to not find them
16017     if test "x$new_path" = x \
16018         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16019         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16020       new_path=`$CYGPATH -u "$path"`
16021     fi
16022     if test "x$new_path" = x; then
16023       # It's still not found. Now this is an unrecoverable error.
16024       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16025 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16026       has_space=`$ECHO "$complete" | $GREP " "`
16027       if test "x$has_space" != x; then
16028         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16029 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16030       fi
16031       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16032     fi
16033   fi
16034 
16035   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16036   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16037   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16038   # "foo.exe" is OK but "foo" is an error.
16039   #
16040   # This test is therefore slightly more accurate than "test -f" to check for file presence.
16041   # It is also a way to make sure we got the proper file name for the real test later on.
16042   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16043   if test "x$test_shortpath" = x; then
16044     # Short path failed, file does not exist as specified.
16045     # Try adding .exe or .cmd
16046     if test -f "${new_path}.exe"; then
16047       input_to_shortpath="${new_path}.exe"
16048     elif test -f "${new_path}.cmd"; then
16049       input_to_shortpath="${new_path}.cmd"
16050     else
16051       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16052 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16053       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16054 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16055       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16056     fi
16057   else
16058     input_to_shortpath="$new_path"
16059   fi
16060 
16061   # Call helper function which possibly converts this using DOS-style short mode.
16062   # If so, the updated path is stored in $new_path.
16063   new_path="$input_to_shortpath"
16064 
16065   input_path="$input_to_shortpath"
16066   # Check if we need to convert this using DOS-style short mode. If the path
16067   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16068   # take no chances and rewrite it.
16069   # Note: m4 eats our [], so we need to use [ and ] instead.
16070   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16071   if test "x$has_forbidden_chars" != x; then
16072     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16073     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16074     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16075     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16076       # Going to short mode and back again did indeed matter. Since short mode is
16077       # case insensitive, let's make it lowercase to improve readability.
16078       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16079       # Now convert it back to Unix-stile (cygpath)
16080       input_path=`$CYGPATH -u "$shortmode_path"`
16081       new_path="$input_path"
16082     fi
16083   fi
16084 
16085   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16086   if test "x$test_cygdrive_prefix" = x; then
16087     # As a simple fix, exclude /usr/bin since it's not a real path.
16088     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16089       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16090       # a path prefixed by /cygdrive for fixpath to work.
16091       new_path="$CYGWIN_ROOT_PATH$input_path"
16092     fi
16093   fi
16094 
16095   # remove trailing .exe if any
16096   new_path="${new_path/%.exe/}"
16097 
16098   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16099 
16100   # First separate the path from the arguments. This will split at the first
16101   # space.
16102   complete="$FOUND_MAKE"
16103   path="${complete%% *}"
16104   tmp="$complete EOL"
16105   arguments="${tmp#* }"
16106 
16107   # Input might be given as Windows format, start by converting to
16108   # unix format.
16109   new_path="$path"
16110 
16111   windows_path="$new_path"
16112   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16113     unix_path=`$CYGPATH -u "$windows_path"`
16114     new_path="$unix_path"
16115   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16116     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16117     new_path="$unix_path"
16118   fi
16119 
16120 
16121   # Now try to locate executable using which
16122   new_path=`$WHICH "$new_path" 2> /dev/null`
16123 
16124   if test "x$new_path" = x; then
16125     # Oops. Which didn't find the executable.
16126     # The splitting of arguments from the executable at a space might have been incorrect,
16127     # since paths with space are more likely in Windows. Give it another try with the whole
16128     # argument.
16129     path="$complete"
16130     arguments="EOL"
16131     new_path="$path"
16132 
16133   windows_path="$new_path"
16134   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16135     unix_path=`$CYGPATH -u "$windows_path"`
16136     new_path="$unix_path"
16137   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16138     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16139     new_path="$unix_path"
16140   fi
16141 
16142 
16143     new_path=`$WHICH "$new_path" 2> /dev/null`
16144 
16145     if test "x$new_path" = x; then
16146       # It's still not found. Now this is an unrecoverable error.
16147       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16148 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16149       has_space=`$ECHO "$complete" | $GREP " "`
16150       if test "x$has_space" != x; then
16151         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16152 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16153       fi
16154       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16155     fi
16156   fi
16157 
16158   # Now new_path has a complete unix path to the binary
16159   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16160     # Keep paths in /bin as-is, but remove trailing .exe if any
16161     new_path="${new_path/%.exe/}"
16162     # Do not save /bin paths to all_fixpath_prefixes!
16163   else
16164     # Not in mixed or Windows style, start by that.
16165     new_path=`cmd //c echo $new_path`
16166 
16167   input_path="$new_path"
16168   # Check if we need to convert this using DOS-style short mode. If the path
16169   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16170   # take no chances and rewrite it.
16171   # Note: m4 eats our [], so we need to use [ and ] instead.
16172   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16173   if test "x$has_forbidden_chars" != x; then
16174     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16175     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16176   fi
16177 
16178     # Output is in $new_path
16179 
16180   windows_path="$new_path"
16181   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16182     unix_path=`$CYGPATH -u "$windows_path"`
16183     new_path="$unix_path"
16184   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16185     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16186     new_path="$unix_path"
16187   fi
16188 
16189     # remove trailing .exe if any
16190     new_path="${new_path/%.exe/}"
16191 
16192     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16193     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16194   fi
16195 
16196   else
16197     # We're on a posix platform. Hooray! :)
16198     # First separate the path from the arguments. This will split at the first
16199     # space.
16200     complete="$FOUND_MAKE"
16201     path="${complete%% *}"
16202     tmp="$complete EOL"
16203     arguments="${tmp#* }"
16204 
16205     # Cannot rely on the command "which" here since it doesn't always work.
16206     is_absolute_path=`$ECHO "$path" | $GREP ^/`
16207     if test -z "$is_absolute_path"; then
16208       # Path to executable is not absolute. Find it.
16209       IFS_save="$IFS"
16210       IFS=:
16211       for p in $PATH; do
16212         if test -f "$p/$path" && test -x "$p/$path"; then
16213           new_path="$p/$path"
16214           break
16215         fi
16216       done
16217       IFS="$IFS_save"
16218     else
16219       # This is an absolute path, we can use it without further modifications.
16220       new_path="$path"
16221     fi
16222 
16223     if test "x$new_path" = x; then
16224       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16225 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16226       has_space=`$ECHO "$complete" | $GREP " "`
16227       if test "x$has_space" != x; then
16228         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16229 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16230       fi
16231       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16232     fi
16233   fi
16234 
16235   # Now join together the path and the arguments once again
16236   if test "x$arguments" != xEOL; then
16237     new_complete="$new_path ${arguments% *}"
16238   else
16239     new_complete="$new_path"
16240   fi
16241 
16242   if test "x$complete" != "x$new_complete"; then
16243     FOUND_MAKE="$new_complete"
16244     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16245 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16246   fi
16247 
16248         fi
16249       fi
16250     fi
16251   fi
16252 
16253     fi
16254 
16255     if test "x$FOUND_MAKE" = x; then
16256       if test "x$TOOLCHAIN_PATH" != x; then
16257         # We have a toolchain path, check that as well before giving up.
16258         OLD_PATH=$PATH
16259         PATH=$TOOLCHAIN_PATH:$PATH
16260         for ac_prog in gmake
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_GMAKE+:} false; then :
16267   $as_echo_n "(cached) " >&6
16268 else
16269   case $CHECK_TOOLSDIR_GMAKE in
16270   [\\/]* | ?:[\\/]*)
16271   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # 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_GMAKE="$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_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
16293 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
16294   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
16295 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&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_GMAKE" && break
16303 done
16304 
16305 
16306   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
16307   DESCRIPTION="gmake 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       # This is an absolute path, we can use it without further modifications.
16578       new_path="$path"
16579     fi
16580 
16581     if test "x$new_path" = x; then
16582       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16583 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16584       has_space=`$ECHO "$complete" | $GREP " "`
16585       if test "x$has_space" != x; then
16586         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16587 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16588       fi
16589       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16590     fi
16591   fi
16592 
16593   # Now join together the path and the arguments once again
16594   if test "x$arguments" != xEOL; then
16595     new_complete="$new_path ${arguments% *}"
16596   else
16597     new_complete="$new_path"
16598   fi
16599 
16600   if test "x$complete" != "x$new_complete"; then
16601     FOUND_MAKE="$new_complete"
16602     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16603 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16604   fi
16605 
16606         fi
16607       fi
16608     fi
16609   fi
16610 
16611         if test "x$FOUND_MAKE" = x; then
16612           for ac_prog in make
16613 do
16614   # Extract the first word of "$ac_prog", so it can be a program name with args.
16615 set dummy $ac_prog; ac_word=$2
16616 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16617 $as_echo_n "checking for $ac_word... " >&6; }
16618 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
16619   $as_echo_n "(cached) " >&6
16620 else
16621   case $CHECK_TOOLSDIR_MAKE in
16622   [\\/]* | ?:[\\/]*)
16623   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
16624   ;;
16625   *)
16626   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16627 for as_dir in $PATH
16628 do
16629   IFS=$as_save_IFS
16630   test -z "$as_dir" && as_dir=.
16631     for ac_exec_ext in '' $ac_executable_extensions; do
16632   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16633     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
16634     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16635     break 2
16636   fi
16637 done
16638   done
16639 IFS=$as_save_IFS
16640 
16641   ;;
16642 esac
16643 fi
16644 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
16645 if test -n "$CHECK_TOOLSDIR_MAKE"; then
16646   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
16647 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
16648 else
16649   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16650 $as_echo "no" >&6; }
16651 fi
16652 
16653 
16654   test -n "$CHECK_TOOLSDIR_MAKE" && break
16655 done
16656 
16657 
16658   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
16659   DESCRIPTION="make in tools-dir"
16660   if test "x$MAKE_CANDIDATE" != x; then
16661     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16662 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16663     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16664     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16665     if test "x$IS_GNU_MAKE" = x; then
16666       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16667 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16668     else
16669       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
16670       if test "x$IS_MODERN_MAKE" = x; then
16671         { $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
16672 $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;}
16673       else
16674         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16675           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16676             MAKE_EXPECTED_ENV='cygwin'
16677           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16678             MAKE_EXPECTED_ENV='msys'
16679           else
16680             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16681           fi
16682           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16683           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16684         else
16685           # Not relevant for non-Windows
16686           IS_MAKE_CORRECT_ENV=true
16687         fi
16688         if test "x$IS_MAKE_CORRECT_ENV" = x; then
16689           { $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
16690 $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;}
16691         else
16692           FOUND_MAKE=$MAKE_CANDIDATE
16693 
16694   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16695 
16696   # First separate the path from the arguments. This will split at the first
16697   # space.
16698   complete="$FOUND_MAKE"
16699   path="${complete%% *}"
16700   tmp="$complete EOL"
16701   arguments="${tmp#* }"
16702 
16703   # Input might be given as Windows format, start by converting to
16704   # unix format.
16705   new_path=`$CYGPATH -u "$path"`
16706 
16707   # Now try to locate executable using which
16708   new_path=`$WHICH "$new_path" 2> /dev/null`
16709   # bat and cmd files are not always considered executable in cygwin causing which
16710   # to not find them
16711   if test "x$new_path" = x \
16712       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16713       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16714     new_path=`$CYGPATH -u "$path"`
16715   fi
16716   if test "x$new_path" = x; then
16717     # Oops. Which didn't find the executable.
16718     # The splitting of arguments from the executable at a space might have been incorrect,
16719     # since paths with space are more likely in Windows. Give it another try with the whole
16720     # argument.
16721     path="$complete"
16722     arguments="EOL"
16723     new_path=`$CYGPATH -u "$path"`
16724     new_path=`$WHICH "$new_path" 2> /dev/null`
16725     # bat and cmd files are not always considered executable in cygwin causing which
16726     # to not find them
16727     if test "x$new_path" = x \
16728         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16729         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16730       new_path=`$CYGPATH -u "$path"`
16731     fi
16732     if test "x$new_path" = x; then
16733       # It's still not found. Now this is an unrecoverable error.
16734       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16735 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16736       has_space=`$ECHO "$complete" | $GREP " "`
16737       if test "x$has_space" != x; then
16738         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16739 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16740       fi
16741       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16742     fi
16743   fi
16744 
16745   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16746   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16747   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16748   # "foo.exe" is OK but "foo" is an error.
16749   #
16750   # This test is therefore slightly more accurate than "test -f" to check for file presence.
16751   # It is also a way to make sure we got the proper file name for the real test later on.
16752   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16753   if test "x$test_shortpath" = x; then
16754     # Short path failed, file does not exist as specified.
16755     # Try adding .exe or .cmd
16756     if test -f "${new_path}.exe"; then
16757       input_to_shortpath="${new_path}.exe"
16758     elif test -f "${new_path}.cmd"; then
16759       input_to_shortpath="${new_path}.cmd"
16760     else
16761       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16762 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16763       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16764 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16765       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16766     fi
16767   else
16768     input_to_shortpath="$new_path"
16769   fi
16770 
16771   # Call helper function which possibly converts this using DOS-style short mode.
16772   # If so, the updated path is stored in $new_path.
16773   new_path="$input_to_shortpath"
16774 
16775   input_path="$input_to_shortpath"
16776   # Check if we need to convert this using DOS-style short mode. If the path
16777   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16778   # take no chances and rewrite it.
16779   # Note: m4 eats our [], so we need to use [ and ] instead.
16780   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16781   if test "x$has_forbidden_chars" != x; then
16782     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16783     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16784     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16785     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16786       # Going to short mode and back again did indeed matter. Since short mode is
16787       # case insensitive, let's make it lowercase to improve readability.
16788       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16789       # Now convert it back to Unix-stile (cygpath)
16790       input_path=`$CYGPATH -u "$shortmode_path"`
16791       new_path="$input_path"
16792     fi
16793   fi
16794 
16795   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16796   if test "x$test_cygdrive_prefix" = x; then
16797     # As a simple fix, exclude /usr/bin since it's not a real path.
16798     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16799       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16800       # a path prefixed by /cygdrive for fixpath to work.
16801       new_path="$CYGWIN_ROOT_PATH$input_path"
16802     fi
16803   fi
16804 
16805   # remove trailing .exe if any
16806   new_path="${new_path/%.exe/}"
16807 
16808   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16809 
16810   # First separate the path from the arguments. This will split at the first
16811   # space.
16812   complete="$FOUND_MAKE"
16813   path="${complete%% *}"
16814   tmp="$complete EOL"
16815   arguments="${tmp#* }"
16816 
16817   # Input might be given as Windows format, start by converting to
16818   # unix format.
16819   new_path="$path"
16820 
16821   windows_path="$new_path"
16822   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16823     unix_path=`$CYGPATH -u "$windows_path"`
16824     new_path="$unix_path"
16825   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16826     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16827     new_path="$unix_path"
16828   fi
16829 
16830 
16831   # Now try to locate executable using which
16832   new_path=`$WHICH "$new_path" 2> /dev/null`
16833 
16834   if test "x$new_path" = x; then
16835     # Oops. Which didn't find the executable.
16836     # The splitting of arguments from the executable at a space might have been incorrect,
16837     # since paths with space are more likely in Windows. Give it another try with the whole
16838     # argument.
16839     path="$complete"
16840     arguments="EOL"
16841     new_path="$path"
16842 
16843   windows_path="$new_path"
16844   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16845     unix_path=`$CYGPATH -u "$windows_path"`
16846     new_path="$unix_path"
16847   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16848     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16849     new_path="$unix_path"
16850   fi
16851 
16852 
16853     new_path=`$WHICH "$new_path" 2> /dev/null`
16854 
16855     if test "x$new_path" = x; then
16856       # It's still not found. Now this is an unrecoverable error.
16857       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16858 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16859       has_space=`$ECHO "$complete" | $GREP " "`
16860       if test "x$has_space" != x; then
16861         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16862 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16863       fi
16864       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16865     fi
16866   fi
16867 
16868   # Now new_path has a complete unix path to the binary
16869   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16870     # Keep paths in /bin as-is, but remove trailing .exe if any
16871     new_path="${new_path/%.exe/}"
16872     # Do not save /bin paths to all_fixpath_prefixes!
16873   else
16874     # Not in mixed or Windows style, start by that.
16875     new_path=`cmd //c echo $new_path`
16876 
16877   input_path="$new_path"
16878   # Check if we need to convert this using DOS-style short mode. If the path
16879   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16880   # take no chances and rewrite it.
16881   # Note: m4 eats our [], so we need to use [ and ] instead.
16882   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16883   if test "x$has_forbidden_chars" != x; then
16884     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16885     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16886   fi
16887 
16888     # Output is in $new_path
16889 
16890   windows_path="$new_path"
16891   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16892     unix_path=`$CYGPATH -u "$windows_path"`
16893     new_path="$unix_path"
16894   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16895     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16896     new_path="$unix_path"
16897   fi
16898 
16899     # remove trailing .exe if any
16900     new_path="${new_path/%.exe/}"
16901 
16902     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16903     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16904   fi
16905 
16906   else
16907     # We're on a posix platform. Hooray! :)
16908     # First separate the path from the arguments. This will split at the first
16909     # space.
16910     complete="$FOUND_MAKE"
16911     path="${complete%% *}"
16912     tmp="$complete EOL"
16913     arguments="${tmp#* }"
16914 
16915     # Cannot rely on the command "which" here since it doesn't always work.
16916     is_absolute_path=`$ECHO "$path" | $GREP ^/`
16917     if test -z "$is_absolute_path"; then
16918       # Path to executable is not absolute. Find it.
16919       IFS_save="$IFS"
16920       IFS=:
16921       for p in $PATH; do
16922         if test -f "$p/$path" && test -x "$p/$path"; then
16923           new_path="$p/$path"
16924           break
16925         fi
16926       done
16927       IFS="$IFS_save"
16928     else
16929       # This is an absolute path, we can use it without further modifications.
16930       new_path="$path"
16931     fi
16932 
16933     if test "x$new_path" = x; then
16934       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16935 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16936       has_space=`$ECHO "$complete" | $GREP " "`
16937       if test "x$has_space" != x; then
16938         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16939 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16940       fi
16941       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16942     fi
16943   fi
16944 
16945   # Now join together the path and the arguments once again
16946   if test "x$arguments" != xEOL; then
16947     new_complete="$new_path ${arguments% *}"
16948   else
16949     new_complete="$new_path"
16950   fi
16951 
16952   if test "x$complete" != "x$new_complete"; then
16953     FOUND_MAKE="$new_complete"
16954     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16955 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16956   fi
16957 
16958         fi
16959       fi
16960     fi
16961   fi
16962 
16963         fi
16964         PATH=$OLD_PATH
16965       fi
16966     fi
16967 
16968     if test "x$FOUND_MAKE" = x; then
16969       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
16970     fi
16971   fi
16972 
16973   MAKE=$FOUND_MAKE
16974 
16975   { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
16976 $as_echo "$as_me: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
16977 
16978 
16979 
16980   # Test if find supports -delete
16981   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
16982 $as_echo_n "checking if find supports -delete... " >&6; }
16983   FIND_DELETE="-delete"
16984 
16985   DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
16986 
16987   echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
16988 
16989   TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
16990   if test -f $DELETEDIR/TestIfFindSupportsDelete; then
16991     # No, it does not.
16992     rm $DELETEDIR/TestIfFindSupportsDelete
16993     FIND_DELETE="-exec rm \{\} \+"
16994     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16995 $as_echo "no" >&6; }
16996   else
16997     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
16998 $as_echo "yes" >&6; }
16999   fi
17000   rmdir $DELETEDIR
17001 
17002 
17003 
17004   # These tools might not be installed by default,
17005   # need hint on how to install them.
17006 
17007 
17008 
17009   # Publish this variable in the help.
17010 
17011 
17012   if test "x$UNZIP" = x; then
17013     # The variable is not set by user, try to locate tool using the code snippet
17014     for ac_prog in unzip
17015 do
17016   # Extract the first word of "$ac_prog", so it can be a program name with args.
17017 set dummy $ac_prog; ac_word=$2
17018 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17019 $as_echo_n "checking for $ac_word... " >&6; }
17020 if ${ac_cv_path_UNZIP+:} false; then :
17021   $as_echo_n "(cached) " >&6
17022 else
17023   case $UNZIP in
17024   [\\/]* | ?:[\\/]*)
17025   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17026   ;;
17027   *)
17028   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17029 for as_dir in $PATH
17030 do
17031   IFS=$as_save_IFS
17032   test -z "$as_dir" && as_dir=.
17033     for ac_exec_ext in '' $ac_executable_extensions; do
17034   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17035     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17036     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17037     break 2
17038   fi
17039 done
17040   done
17041 IFS=$as_save_IFS
17042 
17043   ;;
17044 esac
17045 fi
17046 UNZIP=$ac_cv_path_UNZIP
17047 if test -n "$UNZIP"; then
17048   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17049 $as_echo "$UNZIP" >&6; }
17050 else
17051   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17052 $as_echo "no" >&6; }
17053 fi
17054 
17055 
17056   test -n "$UNZIP" && break
17057 done
17058 
17059   else
17060     # The variable is set, but is it from the command line or the environment?
17061 
17062     # Try to remove the string !UNZIP! from our list.
17063     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
17064     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17065       # If it failed, the variable was not from the command line. Ignore it,
17066       # but warn the user (except for BASH, which is always set by the calling BASH).
17067       if test "xUNZIP" != xBASH; then
17068         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
17069 $as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
17070       fi
17071       # Try to locate tool using the code snippet
17072       for ac_prog in unzip
17073 do
17074   # Extract the first word of "$ac_prog", so it can be a program name with args.
17075 set dummy $ac_prog; ac_word=$2
17076 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17077 $as_echo_n "checking for $ac_word... " >&6; }
17078 if ${ac_cv_path_UNZIP+:} false; then :
17079   $as_echo_n "(cached) " >&6
17080 else
17081   case $UNZIP in
17082   [\\/]* | ?:[\\/]*)
17083   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17084   ;;
17085   *)
17086   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17087 for as_dir in $PATH
17088 do
17089   IFS=$as_save_IFS
17090   test -z "$as_dir" && as_dir=.
17091     for ac_exec_ext in '' $ac_executable_extensions; do
17092   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17093     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17094     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17095     break 2
17096   fi
17097 done
17098   done
17099 IFS=$as_save_IFS
17100 
17101   ;;
17102 esac
17103 fi
17104 UNZIP=$ac_cv_path_UNZIP
17105 if test -n "$UNZIP"; then
17106   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17107 $as_echo "$UNZIP" >&6; }
17108 else
17109   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17110 $as_echo "no" >&6; }
17111 fi
17112 
17113 
17114   test -n "$UNZIP" && break
17115 done
17116 
17117     else
17118       # If it succeeded, then it was overridden by the user. We will use it
17119       # for the tool.
17120 
17121       # First remove it from the list of overridden variables, so we can test
17122       # for unknown variables in the end.
17123       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17124 
17125       # Check if the provided tool contains a complete path.
17126       tool_specified="$UNZIP"
17127       tool_basename="${tool_specified##*/}"
17128       if test "x$tool_basename" = "x$tool_specified"; then
17129         # A command without a complete path is provided, search $PATH.
17130         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
17131 $as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
17132         # Extract the first word of "$tool_basename", so it can be a program name with args.
17133 set dummy $tool_basename; ac_word=$2
17134 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17135 $as_echo_n "checking for $ac_word... " >&6; }
17136 if ${ac_cv_path_UNZIP+:} false; then :
17137   $as_echo_n "(cached) " >&6
17138 else
17139   case $UNZIP in
17140   [\\/]* | ?:[\\/]*)
17141   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17142   ;;
17143   *)
17144   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17145 for as_dir in $PATH
17146 do
17147   IFS=$as_save_IFS
17148   test -z "$as_dir" && as_dir=.
17149     for ac_exec_ext in '' $ac_executable_extensions; do
17150   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17151     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17152     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17153     break 2
17154   fi
17155 done
17156   done
17157 IFS=$as_save_IFS
17158 
17159   ;;
17160 esac
17161 fi
17162 UNZIP=$ac_cv_path_UNZIP
17163 if test -n "$UNZIP"; then
17164   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17165 $as_echo "$UNZIP" >&6; }
17166 else
17167   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17168 $as_echo "no" >&6; }
17169 fi
17170 
17171 
17172         if test "x$UNZIP" = x; then
17173           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17174         fi
17175       else
17176         # Otherwise we believe it is a complete path. Use it as it is.
17177         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
17178 $as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
17179         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
17180 $as_echo_n "checking for UNZIP... " >&6; }
17181         if test ! -x "$tool_specified"; then
17182           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17183 $as_echo "not found" >&6; }
17184           as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17185         fi
17186         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17187 $as_echo "$tool_specified" >&6; }
17188       fi
17189     fi
17190   fi
17191 
17192 
17193 
17194   if test "x$UNZIP" = x; then
17195     as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
17196   fi
17197 
17198 
17199 
17200 
17201 
17202   # Publish this variable in the help.
17203 
17204 
17205   if test "x$ZIP" = x; then
17206     # The variable is not set by user, try to locate tool using the code snippet
17207     for ac_prog in zip
17208 do
17209   # Extract the first word of "$ac_prog", so it can be a program name with args.
17210 set dummy $ac_prog; ac_word=$2
17211 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17212 $as_echo_n "checking for $ac_word... " >&6; }
17213 if ${ac_cv_path_ZIP+:} false; then :
17214   $as_echo_n "(cached) " >&6
17215 else
17216   case $ZIP in
17217   [\\/]* | ?:[\\/]*)
17218   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17219   ;;
17220   *)
17221   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17222 for as_dir in $PATH
17223 do
17224   IFS=$as_save_IFS
17225   test -z "$as_dir" && as_dir=.
17226     for ac_exec_ext in '' $ac_executable_extensions; do
17227   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17228     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17229     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17230     break 2
17231   fi
17232 done
17233   done
17234 IFS=$as_save_IFS
17235 
17236   ;;
17237 esac
17238 fi
17239 ZIP=$ac_cv_path_ZIP
17240 if test -n "$ZIP"; then
17241   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17242 $as_echo "$ZIP" >&6; }
17243 else
17244   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17245 $as_echo "no" >&6; }
17246 fi
17247 
17248 
17249   test -n "$ZIP" && break
17250 done
17251 
17252   else
17253     # The variable is set, but is it from the command line or the environment?
17254 
17255     # Try to remove the string !ZIP! from our list.
17256     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIP!/}
17257     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17258       # If it failed, the variable was not from the command line. Ignore it,
17259       # but warn the user (except for BASH, which is always set by the calling BASH).
17260       if test "xZIP" != xBASH; then
17261         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
17262 $as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
17263       fi
17264       # Try to locate tool using the code snippet
17265       for ac_prog in zip
17266 do
17267   # Extract the first word of "$ac_prog", so it can be a program name with args.
17268 set dummy $ac_prog; ac_word=$2
17269 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17270 $as_echo_n "checking for $ac_word... " >&6; }
17271 if ${ac_cv_path_ZIP+:} false; then :
17272   $as_echo_n "(cached) " >&6
17273 else
17274   case $ZIP in
17275   [\\/]* | ?:[\\/]*)
17276   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17277   ;;
17278   *)
17279   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17280 for as_dir in $PATH
17281 do
17282   IFS=$as_save_IFS
17283   test -z "$as_dir" && as_dir=.
17284     for ac_exec_ext in '' $ac_executable_extensions; do
17285   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17286     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17287     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17288     break 2
17289   fi
17290 done
17291   done
17292 IFS=$as_save_IFS
17293 
17294   ;;
17295 esac
17296 fi
17297 ZIP=$ac_cv_path_ZIP
17298 if test -n "$ZIP"; then
17299   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17300 $as_echo "$ZIP" >&6; }
17301 else
17302   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17303 $as_echo "no" >&6; }
17304 fi
17305 
17306 
17307   test -n "$ZIP" && break
17308 done
17309 
17310     else
17311       # If it succeeded, then it was overridden by the user. We will use it
17312       # for the tool.
17313 
17314       # First remove it from the list of overridden variables, so we can test
17315       # for unknown variables in the end.
17316       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17317 
17318       # Check if the provided tool contains a complete path.
17319       tool_specified="$ZIP"
17320       tool_basename="${tool_specified##*/}"
17321       if test "x$tool_basename" = "x$tool_specified"; then
17322         # A command without a complete path is provided, search $PATH.
17323         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
17324 $as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
17325         # Extract the first word of "$tool_basename", so it can be a program name with args.
17326 set dummy $tool_basename; ac_word=$2
17327 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17328 $as_echo_n "checking for $ac_word... " >&6; }
17329 if ${ac_cv_path_ZIP+:} false; then :
17330   $as_echo_n "(cached) " >&6
17331 else
17332   case $ZIP in
17333   [\\/]* | ?:[\\/]*)
17334   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17335   ;;
17336   *)
17337   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17338 for as_dir in $PATH
17339 do
17340   IFS=$as_save_IFS
17341   test -z "$as_dir" && as_dir=.
17342     for ac_exec_ext in '' $ac_executable_extensions; do
17343   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17344     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17345     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17346     break 2
17347   fi
17348 done
17349   done
17350 IFS=$as_save_IFS
17351 
17352   ;;
17353 esac
17354 fi
17355 ZIP=$ac_cv_path_ZIP
17356 if test -n "$ZIP"; then
17357   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17358 $as_echo "$ZIP" >&6; }
17359 else
17360   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17361 $as_echo "no" >&6; }
17362 fi
17363 
17364 
17365         if test "x$ZIP" = x; then
17366           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17367         fi
17368       else
17369         # Otherwise we believe it is a complete path. Use it as it is.
17370         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
17371 $as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
17372         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
17373 $as_echo_n "checking for ZIP... " >&6; }
17374         if test ! -x "$tool_specified"; then
17375           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17376 $as_echo "not found" >&6; }
17377           as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17378         fi
17379         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17380 $as_echo "$tool_specified" >&6; }
17381       fi
17382     fi
17383   fi
17384 
17385 
17386 
17387   if test "x$ZIP" = x; then
17388     as_fn_error $? "Could not find required tool for ZIP" "$LINENO" 5
17389   fi
17390 
17391 
17392 
17393   # Non-required basic tools
17394 
17395 
17396 
17397   # Publish this variable in the help.
17398 
17399 
17400   if test "x$LDD" = x; then
17401     # The variable is not set by user, try to locate tool using the code snippet
17402     for ac_prog in ldd
17403 do
17404   # Extract the first word of "$ac_prog", so it can be a program name with args.
17405 set dummy $ac_prog; ac_word=$2
17406 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17407 $as_echo_n "checking for $ac_word... " >&6; }
17408 if ${ac_cv_path_LDD+:} false; then :
17409   $as_echo_n "(cached) " >&6
17410 else
17411   case $LDD in
17412   [\\/]* | ?:[\\/]*)
17413   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17414   ;;
17415   *)
17416   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17417 for as_dir in $PATH
17418 do
17419   IFS=$as_save_IFS
17420   test -z "$as_dir" && as_dir=.
17421     for ac_exec_ext in '' $ac_executable_extensions; do
17422   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17423     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17424     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17425     break 2
17426   fi
17427 done
17428   done
17429 IFS=$as_save_IFS
17430 
17431   ;;
17432 esac
17433 fi
17434 LDD=$ac_cv_path_LDD
17435 if test -n "$LDD"; then
17436   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17437 $as_echo "$LDD" >&6; }
17438 else
17439   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17440 $as_echo "no" >&6; }
17441 fi
17442 
17443 
17444   test -n "$LDD" && break
17445 done
17446 
17447   else
17448     # The variable is set, but is it from the command line or the environment?
17449 
17450     # Try to remove the string !LDD! from our list.
17451     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
17452     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17453       # If it failed, the variable was not from the command line. Ignore it,
17454       # but warn the user (except for BASH, which is always set by the calling BASH).
17455       if test "xLDD" != xBASH; then
17456         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
17457 $as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
17458       fi
17459       # Try to locate tool using the code snippet
17460       for ac_prog in ldd
17461 do
17462   # Extract the first word of "$ac_prog", so it can be a program name with args.
17463 set dummy $ac_prog; ac_word=$2
17464 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17465 $as_echo_n "checking for $ac_word... " >&6; }
17466 if ${ac_cv_path_LDD+:} false; then :
17467   $as_echo_n "(cached) " >&6
17468 else
17469   case $LDD in
17470   [\\/]* | ?:[\\/]*)
17471   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17472   ;;
17473   *)
17474   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17475 for as_dir in $PATH
17476 do
17477   IFS=$as_save_IFS
17478   test -z "$as_dir" && as_dir=.
17479     for ac_exec_ext in '' $ac_executable_extensions; do
17480   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17481     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17482     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17483     break 2
17484   fi
17485 done
17486   done
17487 IFS=$as_save_IFS
17488 
17489   ;;
17490 esac
17491 fi
17492 LDD=$ac_cv_path_LDD
17493 if test -n "$LDD"; then
17494   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17495 $as_echo "$LDD" >&6; }
17496 else
17497   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17498 $as_echo "no" >&6; }
17499 fi
17500 
17501 
17502   test -n "$LDD" && break
17503 done
17504 
17505     else
17506       # If it succeeded, then it was overridden by the user. We will use it
17507       # for the tool.
17508 
17509       # First remove it from the list of overridden variables, so we can test
17510       # for unknown variables in the end.
17511       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17512 
17513       # Check if the provided tool contains a complete path.
17514       tool_specified="$LDD"
17515       tool_basename="${tool_specified##*/}"
17516       if test "x$tool_basename" = "x$tool_specified"; then
17517         # A command without a complete path is provided, search $PATH.
17518         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
17519 $as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
17520         # Extract the first word of "$tool_basename", so it can be a program name with args.
17521 set dummy $tool_basename; ac_word=$2
17522 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17523 $as_echo_n "checking for $ac_word... " >&6; }
17524 if ${ac_cv_path_LDD+:} false; then :
17525   $as_echo_n "(cached) " >&6
17526 else
17527   case $LDD in
17528   [\\/]* | ?:[\\/]*)
17529   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17530   ;;
17531   *)
17532   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17533 for as_dir in $PATH
17534 do
17535   IFS=$as_save_IFS
17536   test -z "$as_dir" && as_dir=.
17537     for ac_exec_ext in '' $ac_executable_extensions; do
17538   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17539     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17540     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17541     break 2
17542   fi
17543 done
17544   done
17545 IFS=$as_save_IFS
17546 
17547   ;;
17548 esac
17549 fi
17550 LDD=$ac_cv_path_LDD
17551 if test -n "$LDD"; then
17552   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17553 $as_echo "$LDD" >&6; }
17554 else
17555   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17556 $as_echo "no" >&6; }
17557 fi
17558 
17559 
17560         if test "x$LDD" = x; then
17561           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17562         fi
17563       else
17564         # Otherwise we believe it is a complete path. Use it as it is.
17565         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
17566 $as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
17567         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
17568 $as_echo_n "checking for LDD... " >&6; }
17569         if test ! -x "$tool_specified"; then
17570           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17571 $as_echo "not found" >&6; }
17572           as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
17573         fi
17574         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17575 $as_echo "$tool_specified" >&6; }
17576       fi
17577     fi
17578   fi
17579 
17580 
17581   if test "x$LDD" = "x"; then
17582     # List shared lib dependencies is used for
17583     # debug output and checking for forbidden dependencies.
17584     # We can build without it.
17585     LDD="true"
17586   fi
17587 
17588 
17589   # Publish this variable in the help.
17590 
17591 
17592   if test "x$OTOOL" = x; then
17593     # The variable is not set by user, try to locate tool using the code snippet
17594     for ac_prog in otool
17595 do
17596   # Extract the first word of "$ac_prog", so it can be a program name with args.
17597 set dummy $ac_prog; ac_word=$2
17598 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17599 $as_echo_n "checking for $ac_word... " >&6; }
17600 if ${ac_cv_path_OTOOL+:} false; then :
17601   $as_echo_n "(cached) " >&6
17602 else
17603   case $OTOOL in
17604   [\\/]* | ?:[\\/]*)
17605   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
17606   ;;
17607   *)
17608   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17609 for as_dir in $PATH
17610 do
17611   IFS=$as_save_IFS
17612   test -z "$as_dir" && as_dir=.
17613     for ac_exec_ext in '' $ac_executable_extensions; do
17614   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17615     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
17616     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17617     break 2
17618   fi
17619 done
17620   done
17621 IFS=$as_save_IFS
17622 
17623   ;;
17624 esac
17625 fi
17626 OTOOL=$ac_cv_path_OTOOL
17627 if test -n "$OTOOL"; then
17628   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
17629 $as_echo "$OTOOL" >&6; }
17630 else
17631   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17632 $as_echo "no" >&6; }
17633 fi
17634 
17635 
17636   test -n "$OTOOL" && break
17637 done
17638 
17639   else
17640     # The variable is set, but is it from the command line or the environment?
17641 
17642     # Try to remove the string !OTOOL! from our list.
17643     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OTOOL!/}
17644     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17645       # If it failed, the variable was not from the command line. Ignore it,
17646       # but warn the user (except for BASH, which is always set by the calling BASH).
17647       if test "xOTOOL" != xBASH; then
17648         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&5
17649 $as_echo "$as_me: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&2;}
17650       fi
17651       # Try to locate tool using the code snippet
17652       for ac_prog in otool
17653 do
17654   # Extract the first word of "$ac_prog", so it can be a program name with args.
17655 set dummy $ac_prog; ac_word=$2
17656 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17657 $as_echo_n "checking for $ac_word... " >&6; }
17658 if ${ac_cv_path_OTOOL+:} false; then :
17659   $as_echo_n "(cached) " >&6
17660 else
17661   case $OTOOL in
17662   [\\/]* | ?:[\\/]*)
17663   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
17664   ;;
17665   *)
17666   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17667 for as_dir in $PATH
17668 do
17669   IFS=$as_save_IFS
17670   test -z "$as_dir" && as_dir=.
17671     for ac_exec_ext in '' $ac_executable_extensions; do
17672   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17673     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
17674     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17675     break 2
17676   fi
17677 done
17678   done
17679 IFS=$as_save_IFS
17680 
17681   ;;
17682 esac
17683 fi
17684 OTOOL=$ac_cv_path_OTOOL
17685 if test -n "$OTOOL"; then
17686   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
17687 $as_echo "$OTOOL" >&6; }
17688 else
17689   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17690 $as_echo "no" >&6; }
17691 fi
17692 
17693 
17694   test -n "$OTOOL" && break
17695 done
17696 
17697     else
17698       # If it succeeded, then it was overridden by the user. We will use it
17699       # for the tool.
17700 
17701       # First remove it from the list of overridden variables, so we can test
17702       # for unknown variables in the end.
17703       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17704 
17705       # Check if the provided tool contains a complete path.
17706       tool_specified="$OTOOL"
17707       tool_basename="${tool_specified##*/}"
17708       if test "x$tool_basename" = "x$tool_specified"; then
17709         # A command without a complete path is provided, search $PATH.
17710         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OTOOL=$tool_basename" >&5
17711 $as_echo "$as_me: Will search for user supplied tool OTOOL=$tool_basename" >&6;}
17712         # Extract the first word of "$tool_basename", so it can be a program name with args.
17713 set dummy $tool_basename; ac_word=$2
17714 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17715 $as_echo_n "checking for $ac_word... " >&6; }
17716 if ${ac_cv_path_OTOOL+:} false; then :
17717   $as_echo_n "(cached) " >&6
17718 else
17719   case $OTOOL in
17720   [\\/]* | ?:[\\/]*)
17721   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
17722   ;;
17723   *)
17724   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17725 for as_dir in $PATH
17726 do
17727   IFS=$as_save_IFS
17728   test -z "$as_dir" && as_dir=.
17729     for ac_exec_ext in '' $ac_executable_extensions; do
17730   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17731     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
17732     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17733     break 2
17734   fi
17735 done
17736   done
17737 IFS=$as_save_IFS
17738 
17739   ;;
17740 esac
17741 fi
17742 OTOOL=$ac_cv_path_OTOOL
17743 if test -n "$OTOOL"; then
17744   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
17745 $as_echo "$OTOOL" >&6; }
17746 else
17747   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17748 $as_echo "no" >&6; }
17749 fi
17750 
17751 
17752         if test "x$OTOOL" = x; then
17753           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17754         fi
17755       else
17756         # Otherwise we believe it is a complete path. Use it as it is.
17757         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OTOOL=$tool_specified" >&5
17758 $as_echo "$as_me: Will use user supplied tool OTOOL=$tool_specified" >&6;}
17759         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
17760 $as_echo_n "checking for OTOOL... " >&6; }
17761         if test ! -x "$tool_specified"; then
17762           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17763 $as_echo "not found" >&6; }
17764           as_fn_error $? "User supplied tool OTOOL=$tool_specified does not exist or is not executable" "$LINENO" 5
17765         fi
17766         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17767 $as_echo "$tool_specified" >&6; }
17768       fi
17769     fi
17770   fi
17771 
17772 
17773   if test "x$OTOOL" = "x"; then
17774     OTOOL="true"
17775   fi
17776 
17777 
17778   # Publish this variable in the help.
17779 
17780 
17781   if test "x$READELF" = x; then
17782     # The variable is not set by user, try to locate tool using the code snippet
17783     for ac_prog in greadelf readelf
17784 do
17785   # Extract the first word of "$ac_prog", so it can be a program name with args.
17786 set dummy $ac_prog; ac_word=$2
17787 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17788 $as_echo_n "checking for $ac_word... " >&6; }
17789 if ${ac_cv_path_READELF+:} false; then :
17790   $as_echo_n "(cached) " >&6
17791 else
17792   case $READELF in
17793   [\\/]* | ?:[\\/]*)
17794   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
17795   ;;
17796   *)
17797   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17798 for as_dir in $PATH
17799 do
17800   IFS=$as_save_IFS
17801   test -z "$as_dir" && as_dir=.
17802     for ac_exec_ext in '' $ac_executable_extensions; do
17803   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17804     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
17805     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17806     break 2
17807   fi
17808 done
17809   done
17810 IFS=$as_save_IFS
17811 
17812   ;;
17813 esac
17814 fi
17815 READELF=$ac_cv_path_READELF
17816 if test -n "$READELF"; then
17817   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
17818 $as_echo "$READELF" >&6; }
17819 else
17820   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17821 $as_echo "no" >&6; }
17822 fi
17823 
17824 
17825   test -n "$READELF" && break
17826 done
17827 
17828   else
17829     # The variable is set, but is it from the command line or the environment?
17830 
17831     # Try to remove the string !READELF! from our list.
17832     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
17833     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17834       # If it failed, the variable was not from the command line. Ignore it,
17835       # but warn the user (except for BASH, which is always set by the calling BASH).
17836       if test "xREADELF" != xBASH; then
17837         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
17838 $as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
17839       fi
17840       # Try to locate tool using the code snippet
17841       for ac_prog in greadelf readelf
17842 do
17843   # Extract the first word of "$ac_prog", so it can be a program name with args.
17844 set dummy $ac_prog; ac_word=$2
17845 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17846 $as_echo_n "checking for $ac_word... " >&6; }
17847 if ${ac_cv_path_READELF+:} false; then :
17848   $as_echo_n "(cached) " >&6
17849 else
17850   case $READELF in
17851   [\\/]* | ?:[\\/]*)
17852   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
17853   ;;
17854   *)
17855   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17856 for as_dir in $PATH
17857 do
17858   IFS=$as_save_IFS
17859   test -z "$as_dir" && as_dir=.
17860     for ac_exec_ext in '' $ac_executable_extensions; do
17861   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17862     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
17863     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17864     break 2
17865   fi
17866 done
17867   done
17868 IFS=$as_save_IFS
17869 
17870   ;;
17871 esac
17872 fi
17873 READELF=$ac_cv_path_READELF
17874 if test -n "$READELF"; then
17875   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
17876 $as_echo "$READELF" >&6; }
17877 else
17878   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17879 $as_echo "no" >&6; }
17880 fi
17881 
17882 
17883   test -n "$READELF" && break
17884 done
17885 
17886     else
17887       # If it succeeded, then it was overridden by the user. We will use it
17888       # for the tool.
17889 
17890       # First remove it from the list of overridden variables, so we can test
17891       # for unknown variables in the end.
17892       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17893 
17894       # Check if the provided tool contains a complete path.
17895       tool_specified="$READELF"
17896       tool_basename="${tool_specified##*/}"
17897       if test "x$tool_basename" = "x$tool_specified"; then
17898         # A command without a complete path is provided, search $PATH.
17899         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
17900 $as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
17901         # Extract the first word of "$tool_basename", so it can be a program name with args.
17902 set dummy $tool_basename; ac_word=$2
17903 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17904 $as_echo_n "checking for $ac_word... " >&6; }
17905 if ${ac_cv_path_READELF+:} false; then :
17906   $as_echo_n "(cached) " >&6
17907 else
17908   case $READELF in
17909   [\\/]* | ?:[\\/]*)
17910   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
17911   ;;
17912   *)
17913   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17914 for as_dir in $PATH
17915 do
17916   IFS=$as_save_IFS
17917   test -z "$as_dir" && as_dir=.
17918     for ac_exec_ext in '' $ac_executable_extensions; do
17919   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17920     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
17921     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17922     break 2
17923   fi
17924 done
17925   done
17926 IFS=$as_save_IFS
17927 
17928   ;;
17929 esac
17930 fi
17931 READELF=$ac_cv_path_READELF
17932 if test -n "$READELF"; then
17933   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
17934 $as_echo "$READELF" >&6; }
17935 else
17936   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17937 $as_echo "no" >&6; }
17938 fi
17939 
17940 
17941         if test "x$READELF" = x; then
17942           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17943         fi
17944       else
17945         # Otherwise we believe it is a complete path. Use it as it is.
17946         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
17947 $as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
17948         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
17949 $as_echo_n "checking for READELF... " >&6; }
17950         if test ! -x "$tool_specified"; then
17951           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17952 $as_echo "not found" >&6; }
17953           as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
17954         fi
17955         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17956 $as_echo "$tool_specified" >&6; }
17957       fi
17958     fi
17959   fi
17960 
17961 
17962 
17963 
17964   # Publish this variable in the help.
17965 
17966 
17967   if test "x$HG" = x; then
17968     # The variable is not set by user, try to locate tool using the code snippet
17969     for ac_prog in hg
17970 do
17971   # Extract the first word of "$ac_prog", so it can be a program name with args.
17972 set dummy $ac_prog; ac_word=$2
17973 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17974 $as_echo_n "checking for $ac_word... " >&6; }
17975 if ${ac_cv_path_HG+:} false; then :
17976   $as_echo_n "(cached) " >&6
17977 else
17978   case $HG in
17979   [\\/]* | ?:[\\/]*)
17980   ac_cv_path_HG="$HG" # Let the user override the test with a path.
17981   ;;
17982   *)
17983   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17984 for as_dir in $PATH
17985 do
17986   IFS=$as_save_IFS
17987   test -z "$as_dir" && as_dir=.
17988     for ac_exec_ext in '' $ac_executable_extensions; do
17989   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17990     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
17991     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17992     break 2
17993   fi
17994 done
17995   done
17996 IFS=$as_save_IFS
17997 
17998   ;;
17999 esac
18000 fi
18001 HG=$ac_cv_path_HG
18002 if test -n "$HG"; then
18003   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18004 $as_echo "$HG" >&6; }
18005 else
18006   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18007 $as_echo "no" >&6; }
18008 fi
18009 
18010 
18011   test -n "$HG" && break
18012 done
18013 
18014   else
18015     # The variable is set, but is it from the command line or the environment?
18016 
18017     # Try to remove the string !HG! from our list.
18018     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
18019     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18020       # If it failed, the variable was not from the command line. Ignore it,
18021       # but warn the user (except for BASH, which is always set by the calling BASH).
18022       if test "xHG" != xBASH; then
18023         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
18024 $as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
18025       fi
18026       # Try to locate tool using the code snippet
18027       for ac_prog in hg
18028 do
18029   # Extract the first word of "$ac_prog", so it can be a program name with args.
18030 set dummy $ac_prog; ac_word=$2
18031 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18032 $as_echo_n "checking for $ac_word... " >&6; }
18033 if ${ac_cv_path_HG+:} false; then :
18034   $as_echo_n "(cached) " >&6
18035 else
18036   case $HG in
18037   [\\/]* | ?:[\\/]*)
18038   ac_cv_path_HG="$HG" # Let the user override the test with a path.
18039   ;;
18040   *)
18041   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18042 for as_dir in $PATH
18043 do
18044   IFS=$as_save_IFS
18045   test -z "$as_dir" && as_dir=.
18046     for ac_exec_ext in '' $ac_executable_extensions; do
18047   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18048     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18049     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18050     break 2
18051   fi
18052 done
18053   done
18054 IFS=$as_save_IFS
18055 
18056   ;;
18057 esac
18058 fi
18059 HG=$ac_cv_path_HG
18060 if test -n "$HG"; then
18061   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18062 $as_echo "$HG" >&6; }
18063 else
18064   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18065 $as_echo "no" >&6; }
18066 fi
18067 
18068 
18069   test -n "$HG" && break
18070 done
18071 
18072     else
18073       # If it succeeded, then it was overridden by the user. We will use it
18074       # for the tool.
18075 
18076       # First remove it from the list of overridden variables, so we can test
18077       # for unknown variables in the end.
18078       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18079 
18080       # Check if the provided tool contains a complete path.
18081       tool_specified="$HG"
18082       tool_basename="${tool_specified##*/}"
18083       if test "x$tool_basename" = "x$tool_specified"; then
18084         # A command without a complete path is provided, search $PATH.
18085         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
18086 $as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
18087         # Extract the first word of "$tool_basename", so it can be a program name with args.
18088 set dummy $tool_basename; ac_word=$2
18089 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18090 $as_echo_n "checking for $ac_word... " >&6; }
18091 if ${ac_cv_path_HG+:} false; then :
18092   $as_echo_n "(cached) " >&6
18093 else
18094   case $HG in
18095   [\\/]* | ?:[\\/]*)
18096   ac_cv_path_HG="$HG" # Let the user override the test with a path.
18097   ;;
18098   *)
18099   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18100 for as_dir in $PATH
18101 do
18102   IFS=$as_save_IFS
18103   test -z "$as_dir" && as_dir=.
18104     for ac_exec_ext in '' $ac_executable_extensions; do
18105   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18106     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18107     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18108     break 2
18109   fi
18110 done
18111   done
18112 IFS=$as_save_IFS
18113 
18114   ;;
18115 esac
18116 fi
18117 HG=$ac_cv_path_HG
18118 if test -n "$HG"; then
18119   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18120 $as_echo "$HG" >&6; }
18121 else
18122   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18123 $as_echo "no" >&6; }
18124 fi
18125 
18126 
18127         if test "x$HG" = x; then
18128           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18129         fi
18130       else
18131         # Otherwise we believe it is a complete path. Use it as it is.
18132         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
18133 $as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
18134         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
18135 $as_echo_n "checking for HG... " >&6; }
18136         if test ! -x "$tool_specified"; then
18137           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18138 $as_echo "not found" >&6; }
18139           as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
18140         fi
18141         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18142 $as_echo "$tool_specified" >&6; }
18143       fi
18144     fi
18145   fi
18146 
18147 
18148 
18149 
18150   # Publish this variable in the help.
18151 
18152 
18153   if test "x$STAT" = x; then
18154     # The variable is not set by user, try to locate tool using the code snippet
18155     for ac_prog in stat
18156 do
18157   # Extract the first word of "$ac_prog", so it can be a program name with args.
18158 set dummy $ac_prog; ac_word=$2
18159 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18160 $as_echo_n "checking for $ac_word... " >&6; }
18161 if ${ac_cv_path_STAT+:} false; then :
18162   $as_echo_n "(cached) " >&6
18163 else
18164   case $STAT in
18165   [\\/]* | ?:[\\/]*)
18166   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18167   ;;
18168   *)
18169   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18170 for as_dir in $PATH
18171 do
18172   IFS=$as_save_IFS
18173   test -z "$as_dir" && as_dir=.
18174     for ac_exec_ext in '' $ac_executable_extensions; do
18175   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18176     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18177     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18178     break 2
18179   fi
18180 done
18181   done
18182 IFS=$as_save_IFS
18183 
18184   ;;
18185 esac
18186 fi
18187 STAT=$ac_cv_path_STAT
18188 if test -n "$STAT"; then
18189   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18190 $as_echo "$STAT" >&6; }
18191 else
18192   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18193 $as_echo "no" >&6; }
18194 fi
18195 
18196 
18197   test -n "$STAT" && break
18198 done
18199 
18200   else
18201     # The variable is set, but is it from the command line or the environment?
18202 
18203     # Try to remove the string !STAT! from our list.
18204     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
18205     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18206       # If it failed, the variable was not from the command line. Ignore it,
18207       # but warn the user (except for BASH, which is always set by the calling BASH).
18208       if test "xSTAT" != xBASH; then
18209         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
18210 $as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
18211       fi
18212       # Try to locate tool using the code snippet
18213       for ac_prog in stat
18214 do
18215   # Extract the first word of "$ac_prog", so it can be a program name with args.
18216 set dummy $ac_prog; ac_word=$2
18217 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18218 $as_echo_n "checking for $ac_word... " >&6; }
18219 if ${ac_cv_path_STAT+:} false; then :
18220   $as_echo_n "(cached) " >&6
18221 else
18222   case $STAT in
18223   [\\/]* | ?:[\\/]*)
18224   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18225   ;;
18226   *)
18227   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18228 for as_dir in $PATH
18229 do
18230   IFS=$as_save_IFS
18231   test -z "$as_dir" && as_dir=.
18232     for ac_exec_ext in '' $ac_executable_extensions; do
18233   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18234     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18235     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18236     break 2
18237   fi
18238 done
18239   done
18240 IFS=$as_save_IFS
18241 
18242   ;;
18243 esac
18244 fi
18245 STAT=$ac_cv_path_STAT
18246 if test -n "$STAT"; then
18247   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18248 $as_echo "$STAT" >&6; }
18249 else
18250   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18251 $as_echo "no" >&6; }
18252 fi
18253 
18254 
18255   test -n "$STAT" && break
18256 done
18257 
18258     else
18259       # If it succeeded, then it was overridden by the user. We will use it
18260       # for the tool.
18261 
18262       # First remove it from the list of overridden variables, so we can test
18263       # for unknown variables in the end.
18264       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18265 
18266       # Check if the provided tool contains a complete path.
18267       tool_specified="$STAT"
18268       tool_basename="${tool_specified##*/}"
18269       if test "x$tool_basename" = "x$tool_specified"; then
18270         # A command without a complete path is provided, search $PATH.
18271         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
18272 $as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
18273         # Extract the first word of "$tool_basename", so it can be a program name with args.
18274 set dummy $tool_basename; ac_word=$2
18275 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18276 $as_echo_n "checking for $ac_word... " >&6; }
18277 if ${ac_cv_path_STAT+:} false; then :
18278   $as_echo_n "(cached) " >&6
18279 else
18280   case $STAT in
18281   [\\/]* | ?:[\\/]*)
18282   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18283   ;;
18284   *)
18285   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18286 for as_dir in $PATH
18287 do
18288   IFS=$as_save_IFS
18289   test -z "$as_dir" && as_dir=.
18290     for ac_exec_ext in '' $ac_executable_extensions; do
18291   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18292     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18293     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18294     break 2
18295   fi
18296 done
18297   done
18298 IFS=$as_save_IFS
18299 
18300   ;;
18301 esac
18302 fi
18303 STAT=$ac_cv_path_STAT
18304 if test -n "$STAT"; then
18305   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18306 $as_echo "$STAT" >&6; }
18307 else
18308   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18309 $as_echo "no" >&6; }
18310 fi
18311 
18312 
18313         if test "x$STAT" = x; then
18314           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18315         fi
18316       else
18317         # Otherwise we believe it is a complete path. Use it as it is.
18318         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
18319 $as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
18320         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
18321 $as_echo_n "checking for STAT... " >&6; }
18322         if test ! -x "$tool_specified"; then
18323           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18324 $as_echo "not found" >&6; }
18325           as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
18326         fi
18327         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18328 $as_echo "$tool_specified" >&6; }
18329       fi
18330     fi
18331   fi
18332 
18333 
18334 
18335 
18336   # Publish this variable in the help.
18337 
18338 
18339   if test "x$TIME" = x; then
18340     # The variable is not set by user, try to locate tool using the code snippet
18341     for ac_prog in time
18342 do
18343   # Extract the first word of "$ac_prog", so it can be a program name with args.
18344 set dummy $ac_prog; ac_word=$2
18345 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18346 $as_echo_n "checking for $ac_word... " >&6; }
18347 if ${ac_cv_path_TIME+:} false; then :
18348   $as_echo_n "(cached) " >&6
18349 else
18350   case $TIME in
18351   [\\/]* | ?:[\\/]*)
18352   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18353   ;;
18354   *)
18355   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18356 for as_dir in $PATH
18357 do
18358   IFS=$as_save_IFS
18359   test -z "$as_dir" && as_dir=.
18360     for ac_exec_ext in '' $ac_executable_extensions; do
18361   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18362     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18363     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18364     break 2
18365   fi
18366 done
18367   done
18368 IFS=$as_save_IFS
18369 
18370   ;;
18371 esac
18372 fi
18373 TIME=$ac_cv_path_TIME
18374 if test -n "$TIME"; then
18375   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18376 $as_echo "$TIME" >&6; }
18377 else
18378   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18379 $as_echo "no" >&6; }
18380 fi
18381 
18382 
18383   test -n "$TIME" && break
18384 done
18385 
18386   else
18387     # The variable is set, but is it from the command line or the environment?
18388 
18389     # Try to remove the string !TIME! from our list.
18390     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
18391     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18392       # If it failed, the variable was not from the command line. Ignore it,
18393       # but warn the user (except for BASH, which is always set by the calling BASH).
18394       if test "xTIME" != xBASH; then
18395         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
18396 $as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
18397       fi
18398       # Try to locate tool using the code snippet
18399       for ac_prog in time
18400 do
18401   # Extract the first word of "$ac_prog", so it can be a program name with args.
18402 set dummy $ac_prog; ac_word=$2
18403 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18404 $as_echo_n "checking for $ac_word... " >&6; }
18405 if ${ac_cv_path_TIME+:} false; then :
18406   $as_echo_n "(cached) " >&6
18407 else
18408   case $TIME in
18409   [\\/]* | ?:[\\/]*)
18410   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18411   ;;
18412   *)
18413   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18414 for as_dir in $PATH
18415 do
18416   IFS=$as_save_IFS
18417   test -z "$as_dir" && as_dir=.
18418     for ac_exec_ext in '' $ac_executable_extensions; do
18419   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18420     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18421     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18422     break 2
18423   fi
18424 done
18425   done
18426 IFS=$as_save_IFS
18427 
18428   ;;
18429 esac
18430 fi
18431 TIME=$ac_cv_path_TIME
18432 if test -n "$TIME"; then
18433   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18434 $as_echo "$TIME" >&6; }
18435 else
18436   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18437 $as_echo "no" >&6; }
18438 fi
18439 
18440 
18441   test -n "$TIME" && break
18442 done
18443 
18444     else
18445       # If it succeeded, then it was overridden by the user. We will use it
18446       # for the tool.
18447 
18448       # First remove it from the list of overridden variables, so we can test
18449       # for unknown variables in the end.
18450       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18451 
18452       # Check if the provided tool contains a complete path.
18453       tool_specified="$TIME"
18454       tool_basename="${tool_specified##*/}"
18455       if test "x$tool_basename" = "x$tool_specified"; then
18456         # A command without a complete path is provided, search $PATH.
18457         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
18458 $as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
18459         # Extract the first word of "$tool_basename", so it can be a program name with args.
18460 set dummy $tool_basename; ac_word=$2
18461 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18462 $as_echo_n "checking for $ac_word... " >&6; }
18463 if ${ac_cv_path_TIME+:} false; then :
18464   $as_echo_n "(cached) " >&6
18465 else
18466   case $TIME in
18467   [\\/]* | ?:[\\/]*)
18468   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18469   ;;
18470   *)
18471   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18472 for as_dir in $PATH
18473 do
18474   IFS=$as_save_IFS
18475   test -z "$as_dir" && as_dir=.
18476     for ac_exec_ext in '' $ac_executable_extensions; do
18477   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18478     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18479     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18480     break 2
18481   fi
18482 done
18483   done
18484 IFS=$as_save_IFS
18485 
18486   ;;
18487 esac
18488 fi
18489 TIME=$ac_cv_path_TIME
18490 if test -n "$TIME"; then
18491   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18492 $as_echo "$TIME" >&6; }
18493 else
18494   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18495 $as_echo "no" >&6; }
18496 fi
18497 
18498 
18499         if test "x$TIME" = x; then
18500           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18501         fi
18502       else
18503         # Otherwise we believe it is a complete path. Use it as it is.
18504         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
18505 $as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
18506         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
18507 $as_echo_n "checking for TIME... " >&6; }
18508         if test ! -x "$tool_specified"; then
18509           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18510 $as_echo "not found" >&6; }
18511           as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
18512         fi
18513         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18514 $as_echo "$tool_specified" >&6; }
18515       fi
18516     fi
18517   fi
18518 
18519 
18520   # Check if it's GNU time
18521   IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
18522   if test "x$IS_GNU_TIME" != x; then
18523     IS_GNU_TIME=yes
18524   else
18525     IS_GNU_TIME=no
18526   fi
18527 
18528 
18529   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
18530 
18531 
18532 
18533   # Publish this variable in the help.
18534 
18535 
18536   if test "x$COMM" = x; then
18537     # The variable is not set by user, try to locate tool using the code snippet
18538     for ac_prog in comm
18539 do
18540   # Extract the first word of "$ac_prog", so it can be a program name with args.
18541 set dummy $ac_prog; ac_word=$2
18542 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18543 $as_echo_n "checking for $ac_word... " >&6; }
18544 if ${ac_cv_path_COMM+:} false; then :
18545   $as_echo_n "(cached) " >&6
18546 else
18547   case $COMM in
18548   [\\/]* | ?:[\\/]*)
18549   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
18550   ;;
18551   *)
18552   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18553 for as_dir in $PATH
18554 do
18555   IFS=$as_save_IFS
18556   test -z "$as_dir" && as_dir=.
18557     for ac_exec_ext in '' $ac_executable_extensions; do
18558   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18559     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
18560     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18561     break 2
18562   fi
18563 done
18564   done
18565 IFS=$as_save_IFS
18566 
18567   ;;
18568 esac
18569 fi
18570 COMM=$ac_cv_path_COMM
18571 if test -n "$COMM"; then
18572   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
18573 $as_echo "$COMM" >&6; }
18574 else
18575   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18576 $as_echo "no" >&6; }
18577 fi
18578 
18579 
18580   test -n "$COMM" && break
18581 done
18582 
18583   else
18584     # The variable is set, but is it from the command line or the environment?
18585 
18586     # Try to remove the string !COMM! from our list.
18587     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
18588     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18589       # If it failed, the variable was not from the command line. Ignore it,
18590       # but warn the user (except for BASH, which is always set by the calling BASH).
18591       if test "xCOMM" != xBASH; then
18592         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
18593 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
18594       fi
18595       # Try to locate tool using the code snippet
18596       for ac_prog in comm
18597 do
18598   # Extract the first word of "$ac_prog", so it can be a program name with args.
18599 set dummy $ac_prog; ac_word=$2
18600 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18601 $as_echo_n "checking for $ac_word... " >&6; }
18602 if ${ac_cv_path_COMM+:} false; then :
18603   $as_echo_n "(cached) " >&6
18604 else
18605   case $COMM in
18606   [\\/]* | ?:[\\/]*)
18607   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
18608   ;;
18609   *)
18610   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18611 for as_dir in $PATH
18612 do
18613   IFS=$as_save_IFS
18614   test -z "$as_dir" && as_dir=.
18615     for ac_exec_ext in '' $ac_executable_extensions; do
18616   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18617     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
18618     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18619     break 2
18620   fi
18621 done
18622   done
18623 IFS=$as_save_IFS
18624 
18625   ;;
18626 esac
18627 fi
18628 COMM=$ac_cv_path_COMM
18629 if test -n "$COMM"; then
18630   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
18631 $as_echo "$COMM" >&6; }
18632 else
18633   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18634 $as_echo "no" >&6; }
18635 fi
18636 
18637 
18638   test -n "$COMM" && break
18639 done
18640 
18641     else
18642       # If it succeeded, then it was overridden by the user. We will use it
18643       # for the tool.
18644 
18645       # First remove it from the list of overridden variables, so we can test
18646       # for unknown variables in the end.
18647       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18648 
18649       # Check if the provided tool contains a complete path.
18650       tool_specified="$COMM"
18651       tool_basename="${tool_specified##*/}"
18652       if test "x$tool_basename" = "x$tool_specified"; then
18653         # A command without a complete path is provided, search $PATH.
18654         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
18655 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
18656         # Extract the first word of "$tool_basename", so it can be a program name with args.
18657 set dummy $tool_basename; ac_word=$2
18658 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18659 $as_echo_n "checking for $ac_word... " >&6; }
18660 if ${ac_cv_path_COMM+:} false; then :
18661   $as_echo_n "(cached) " >&6
18662 else
18663   case $COMM in
18664   [\\/]* | ?:[\\/]*)
18665   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
18666   ;;
18667   *)
18668   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18669 for as_dir in $PATH
18670 do
18671   IFS=$as_save_IFS
18672   test -z "$as_dir" && as_dir=.
18673     for ac_exec_ext in '' $ac_executable_extensions; do
18674   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18675     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
18676     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18677     break 2
18678   fi
18679 done
18680   done
18681 IFS=$as_save_IFS
18682 
18683   ;;
18684 esac
18685 fi
18686 COMM=$ac_cv_path_COMM
18687 if test -n "$COMM"; then
18688   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
18689 $as_echo "$COMM" >&6; }
18690 else
18691   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18692 $as_echo "no" >&6; }
18693 fi
18694 
18695 
18696         if test "x$COMM" = x; then
18697           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18698         fi
18699       else
18700         # Otherwise we believe it is a complete path. Use it as it is.
18701         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
18702 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
18703         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
18704 $as_echo_n "checking for COMM... " >&6; }
18705         if test ! -x "$tool_specified"; then
18706           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18707 $as_echo "not found" >&6; }
18708           as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
18709         fi
18710         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18711 $as_echo "$tool_specified" >&6; }
18712       fi
18713     fi
18714   fi
18715 
18716 
18717 
18718   if test "x$COMM" = x; then
18719     as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
18720   fi
18721 
18722 
18723   fi
18724 
18725   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
18726 
18727 
18728 
18729   # Publish this variable in the help.
18730 
18731 
18732   if test "x$DSYMUTIL" = x; then
18733     # The variable is not set by user, try to locate tool using the code snippet
18734     for ac_prog in dsymutil
18735 do
18736   # Extract the first word of "$ac_prog", so it can be a program name with args.
18737 set dummy $ac_prog; ac_word=$2
18738 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18739 $as_echo_n "checking for $ac_word... " >&6; }
18740 if ${ac_cv_path_DSYMUTIL+:} false; then :
18741   $as_echo_n "(cached) " >&6
18742 else
18743   case $DSYMUTIL in
18744   [\\/]* | ?:[\\/]*)
18745   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18746   ;;
18747   *)
18748   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18749 for as_dir in $PATH
18750 do
18751   IFS=$as_save_IFS
18752   test -z "$as_dir" && as_dir=.
18753     for ac_exec_ext in '' $ac_executable_extensions; do
18754   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18755     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18756     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18757     break 2
18758   fi
18759 done
18760   done
18761 IFS=$as_save_IFS
18762 
18763   ;;
18764 esac
18765 fi
18766 DSYMUTIL=$ac_cv_path_DSYMUTIL
18767 if test -n "$DSYMUTIL"; then
18768   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18769 $as_echo "$DSYMUTIL" >&6; }
18770 else
18771   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18772 $as_echo "no" >&6; }
18773 fi
18774 
18775 
18776   test -n "$DSYMUTIL" && break
18777 done
18778 
18779   else
18780     # The variable is set, but is it from the command line or the environment?
18781 
18782     # Try to remove the string !DSYMUTIL! from our list.
18783     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
18784     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18785       # If it failed, the variable was not from the command line. Ignore it,
18786       # but warn the user (except for BASH, which is always set by the calling BASH).
18787       if test "xDSYMUTIL" != xBASH; then
18788         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
18789 $as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
18790       fi
18791       # Try to locate tool using the code snippet
18792       for ac_prog in dsymutil
18793 do
18794   # Extract the first word of "$ac_prog", so it can be a program name with args.
18795 set dummy $ac_prog; ac_word=$2
18796 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18797 $as_echo_n "checking for $ac_word... " >&6; }
18798 if ${ac_cv_path_DSYMUTIL+:} false; then :
18799   $as_echo_n "(cached) " >&6
18800 else
18801   case $DSYMUTIL in
18802   [\\/]* | ?:[\\/]*)
18803   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18804   ;;
18805   *)
18806   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18807 for as_dir in $PATH
18808 do
18809   IFS=$as_save_IFS
18810   test -z "$as_dir" && as_dir=.
18811     for ac_exec_ext in '' $ac_executable_extensions; do
18812   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18813     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18814     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18815     break 2
18816   fi
18817 done
18818   done
18819 IFS=$as_save_IFS
18820 
18821   ;;
18822 esac
18823 fi
18824 DSYMUTIL=$ac_cv_path_DSYMUTIL
18825 if test -n "$DSYMUTIL"; then
18826   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18827 $as_echo "$DSYMUTIL" >&6; }
18828 else
18829   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18830 $as_echo "no" >&6; }
18831 fi
18832 
18833 
18834   test -n "$DSYMUTIL" && break
18835 done
18836 
18837     else
18838       # If it succeeded, then it was overridden by the user. We will use it
18839       # for the tool.
18840 
18841       # First remove it from the list of overridden variables, so we can test
18842       # for unknown variables in the end.
18843       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18844 
18845       # Check if the provided tool contains a complete path.
18846       tool_specified="$DSYMUTIL"
18847       tool_basename="${tool_specified##*/}"
18848       if test "x$tool_basename" = "x$tool_specified"; then
18849         # A command without a complete path is provided, search $PATH.
18850         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
18851 $as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
18852         # Extract the first word of "$tool_basename", so it can be a program name with args.
18853 set dummy $tool_basename; ac_word=$2
18854 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18855 $as_echo_n "checking for $ac_word... " >&6; }
18856 if ${ac_cv_path_DSYMUTIL+:} false; then :
18857   $as_echo_n "(cached) " >&6
18858 else
18859   case $DSYMUTIL in
18860   [\\/]* | ?:[\\/]*)
18861   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18862   ;;
18863   *)
18864   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18865 for as_dir in $PATH
18866 do
18867   IFS=$as_save_IFS
18868   test -z "$as_dir" && as_dir=.
18869     for ac_exec_ext in '' $ac_executable_extensions; do
18870   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18871     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18872     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18873     break 2
18874   fi
18875 done
18876   done
18877 IFS=$as_save_IFS
18878 
18879   ;;
18880 esac
18881 fi
18882 DSYMUTIL=$ac_cv_path_DSYMUTIL
18883 if test -n "$DSYMUTIL"; then
18884   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18885 $as_echo "$DSYMUTIL" >&6; }
18886 else
18887   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18888 $as_echo "no" >&6; }
18889 fi
18890 
18891 
18892         if test "x$DSYMUTIL" = x; then
18893           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18894         fi
18895       else
18896         # Otherwise we believe it is a complete path. Use it as it is.
18897         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
18898 $as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
18899         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
18900 $as_echo_n "checking for DSYMUTIL... " >&6; }
18901         if test ! -x "$tool_specified"; then
18902           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18903 $as_echo "not found" >&6; }
18904           as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
18905         fi
18906         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18907 $as_echo "$tool_specified" >&6; }
18908       fi
18909     fi
18910   fi
18911 
18912 
18913 
18914   if test "x$DSYMUTIL" = x; then
18915     as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
18916   fi
18917 
18918 
18919 
18920 
18921 
18922   # Publish this variable in the help.
18923 
18924 
18925   if test "x$XATTR" = x; then
18926     # The variable is not set by user, try to locate tool using the code snippet
18927     for ac_prog in xattr
18928 do
18929   # Extract the first word of "$ac_prog", so it can be a program name with args.
18930 set dummy $ac_prog; ac_word=$2
18931 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18932 $as_echo_n "checking for $ac_word... " >&6; }
18933 if ${ac_cv_path_XATTR+:} false; then :
18934   $as_echo_n "(cached) " >&6
18935 else
18936   case $XATTR in
18937   [\\/]* | ?:[\\/]*)
18938   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
18939   ;;
18940   *)
18941   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18942 for as_dir in $PATH
18943 do
18944   IFS=$as_save_IFS
18945   test -z "$as_dir" && as_dir=.
18946     for ac_exec_ext in '' $ac_executable_extensions; do
18947   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18948     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
18949     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18950     break 2
18951   fi
18952 done
18953   done
18954 IFS=$as_save_IFS
18955 
18956   ;;
18957 esac
18958 fi
18959 XATTR=$ac_cv_path_XATTR
18960 if test -n "$XATTR"; then
18961   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
18962 $as_echo "$XATTR" >&6; }
18963 else
18964   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18965 $as_echo "no" >&6; }
18966 fi
18967 
18968 
18969   test -n "$XATTR" && break
18970 done
18971 
18972   else
18973     # The variable is set, but is it from the command line or the environment?
18974 
18975     # Try to remove the string !XATTR! from our list.
18976     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
18977     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18978       # If it failed, the variable was not from the command line. Ignore it,
18979       # but warn the user (except for BASH, which is always set by the calling BASH).
18980       if test "xXATTR" != xBASH; then
18981         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
18982 $as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
18983       fi
18984       # Try to locate tool using the code snippet
18985       for ac_prog in xattr
18986 do
18987   # Extract the first word of "$ac_prog", so it can be a program name with args.
18988 set dummy $ac_prog; ac_word=$2
18989 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18990 $as_echo_n "checking for $ac_word... " >&6; }
18991 if ${ac_cv_path_XATTR+:} false; then :
18992   $as_echo_n "(cached) " >&6
18993 else
18994   case $XATTR in
18995   [\\/]* | ?:[\\/]*)
18996   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
18997   ;;
18998   *)
18999   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19000 for as_dir in $PATH
19001 do
19002   IFS=$as_save_IFS
19003   test -z "$as_dir" && as_dir=.
19004     for ac_exec_ext in '' $ac_executable_extensions; do
19005   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19006     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19007     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19008     break 2
19009   fi
19010 done
19011   done
19012 IFS=$as_save_IFS
19013 
19014   ;;
19015 esac
19016 fi
19017 XATTR=$ac_cv_path_XATTR
19018 if test -n "$XATTR"; then
19019   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19020 $as_echo "$XATTR" >&6; }
19021 else
19022   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19023 $as_echo "no" >&6; }
19024 fi
19025 
19026 
19027   test -n "$XATTR" && break
19028 done
19029 
19030     else
19031       # If it succeeded, then it was overridden by the user. We will use it
19032       # for the tool.
19033 
19034       # First remove it from the list of overridden variables, so we can test
19035       # for unknown variables in the end.
19036       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19037 
19038       # Check if the provided tool contains a complete path.
19039       tool_specified="$XATTR"
19040       tool_basename="${tool_specified##*/}"
19041       if test "x$tool_basename" = "x$tool_specified"; then
19042         # A command without a complete path is provided, search $PATH.
19043         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
19044 $as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
19045         # Extract the first word of "$tool_basename", so it can be a program name with args.
19046 set dummy $tool_basename; ac_word=$2
19047 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19048 $as_echo_n "checking for $ac_word... " >&6; }
19049 if ${ac_cv_path_XATTR+:} false; then :
19050   $as_echo_n "(cached) " >&6
19051 else
19052   case $XATTR in
19053   [\\/]* | ?:[\\/]*)
19054   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19055   ;;
19056   *)
19057   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19058 for as_dir in $PATH
19059 do
19060   IFS=$as_save_IFS
19061   test -z "$as_dir" && as_dir=.
19062     for ac_exec_ext in '' $ac_executable_extensions; do
19063   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19064     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19065     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19066     break 2
19067   fi
19068 done
19069   done
19070 IFS=$as_save_IFS
19071 
19072   ;;
19073 esac
19074 fi
19075 XATTR=$ac_cv_path_XATTR
19076 if test -n "$XATTR"; then
19077   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19078 $as_echo "$XATTR" >&6; }
19079 else
19080   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19081 $as_echo "no" >&6; }
19082 fi
19083 
19084 
19085         if test "x$XATTR" = x; then
19086           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19087         fi
19088       else
19089         # Otherwise we believe it is a complete path. Use it as it is.
19090         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
19091 $as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
19092         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
19093 $as_echo_n "checking for XATTR... " >&6; }
19094         if test ! -x "$tool_specified"; then
19095           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19096 $as_echo "not found" >&6; }
19097           as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
19098         fi
19099         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19100 $as_echo "$tool_specified" >&6; }
19101       fi
19102     fi
19103   fi
19104 
19105 
19106 
19107   if test "x$XATTR" = x; then
19108     as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
19109   fi
19110 
19111 
19112 
19113 
19114   # Publish this variable in the help.
19115 
19116 
19117   if test "x$CODESIGN" = x; then
19118     # The variable is not set by user, try to locate tool using the code snippet
19119     for ac_prog in codesign
19120 do
19121   # Extract the first word of "$ac_prog", so it can be a program name with args.
19122 set dummy $ac_prog; ac_word=$2
19123 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19124 $as_echo_n "checking for $ac_word... " >&6; }
19125 if ${ac_cv_path_CODESIGN+:} false; then :
19126   $as_echo_n "(cached) " >&6
19127 else
19128   case $CODESIGN in
19129   [\\/]* | ?:[\\/]*)
19130   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19131   ;;
19132   *)
19133   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19134 for as_dir in $PATH
19135 do
19136   IFS=$as_save_IFS
19137   test -z "$as_dir" && as_dir=.
19138     for ac_exec_ext in '' $ac_executable_extensions; do
19139   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19140     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19141     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19142     break 2
19143   fi
19144 done
19145   done
19146 IFS=$as_save_IFS
19147 
19148   ;;
19149 esac
19150 fi
19151 CODESIGN=$ac_cv_path_CODESIGN
19152 if test -n "$CODESIGN"; then
19153   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19154 $as_echo "$CODESIGN" >&6; }
19155 else
19156   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19157 $as_echo "no" >&6; }
19158 fi
19159 
19160 
19161   test -n "$CODESIGN" && break
19162 done
19163 
19164   else
19165     # The variable is set, but is it from the command line or the environment?
19166 
19167     # Try to remove the string !CODESIGN! from our list.
19168     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
19169     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19170       # If it failed, the variable was not from the command line. Ignore it,
19171       # but warn the user (except for BASH, which is always set by the calling BASH).
19172       if test "xCODESIGN" != xBASH; then
19173         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
19174 $as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
19175       fi
19176       # Try to locate tool using the code snippet
19177       for ac_prog in codesign
19178 do
19179   # Extract the first word of "$ac_prog", so it can be a program name with args.
19180 set dummy $ac_prog; ac_word=$2
19181 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19182 $as_echo_n "checking for $ac_word... " >&6; }
19183 if ${ac_cv_path_CODESIGN+:} false; then :
19184   $as_echo_n "(cached) " >&6
19185 else
19186   case $CODESIGN in
19187   [\\/]* | ?:[\\/]*)
19188   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19189   ;;
19190   *)
19191   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19192 for as_dir in $PATH
19193 do
19194   IFS=$as_save_IFS
19195   test -z "$as_dir" && as_dir=.
19196     for ac_exec_ext in '' $ac_executable_extensions; do
19197   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19198     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19199     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19200     break 2
19201   fi
19202 done
19203   done
19204 IFS=$as_save_IFS
19205 
19206   ;;
19207 esac
19208 fi
19209 CODESIGN=$ac_cv_path_CODESIGN
19210 if test -n "$CODESIGN"; then
19211   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19212 $as_echo "$CODESIGN" >&6; }
19213 else
19214   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19215 $as_echo "no" >&6; }
19216 fi
19217 
19218 
19219   test -n "$CODESIGN" && break
19220 done
19221 
19222     else
19223       # If it succeeded, then it was overridden by the user. We will use it
19224       # for the tool.
19225 
19226       # First remove it from the list of overridden variables, so we can test
19227       # for unknown variables in the end.
19228       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19229 
19230       # Check if the provided tool contains a complete path.
19231       tool_specified="$CODESIGN"
19232       tool_basename="${tool_specified##*/}"
19233       if test "x$tool_basename" = "x$tool_specified"; then
19234         # A command without a complete path is provided, search $PATH.
19235         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
19236 $as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
19237         # Extract the first word of "$tool_basename", so it can be a program name with args.
19238 set dummy $tool_basename; ac_word=$2
19239 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19240 $as_echo_n "checking for $ac_word... " >&6; }
19241 if ${ac_cv_path_CODESIGN+:} false; then :
19242   $as_echo_n "(cached) " >&6
19243 else
19244   case $CODESIGN in
19245   [\\/]* | ?:[\\/]*)
19246   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19247   ;;
19248   *)
19249   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19250 for as_dir in $PATH
19251 do
19252   IFS=$as_save_IFS
19253   test -z "$as_dir" && as_dir=.
19254     for ac_exec_ext in '' $ac_executable_extensions; do
19255   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19256     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19257     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19258     break 2
19259   fi
19260 done
19261   done
19262 IFS=$as_save_IFS
19263 
19264   ;;
19265 esac
19266 fi
19267 CODESIGN=$ac_cv_path_CODESIGN
19268 if test -n "$CODESIGN"; then
19269   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19270 $as_echo "$CODESIGN" >&6; }
19271 else
19272   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19273 $as_echo "no" >&6; }
19274 fi
19275 
19276 
19277         if test "x$CODESIGN" = x; then
19278           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19279         fi
19280       else
19281         # Otherwise we believe it is a complete path. Use it as it is.
19282         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
19283 $as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
19284         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
19285 $as_echo_n "checking for CODESIGN... " >&6; }
19286         if test ! -x "$tool_specified"; then
19287           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19288 $as_echo "not found" >&6; }
19289           as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
19290         fi
19291         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19292 $as_echo "$tool_specified" >&6; }
19293       fi
19294     fi
19295   fi
19296 
19297 
19298     if test "x$CODESIGN" != "x"; then
19299       # Verify that the openjdk_codesign certificate is present
19300       { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
19301 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
19302       rm -f codesign-testfile
19303       touch codesign-testfile
19304       codesign -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
19305       rm -f codesign-testfile
19306       if test "x$CODESIGN" = x; then
19307         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19308 $as_echo "no" >&6; }
19309       else
19310         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19311 $as_echo "yes" >&6; }
19312       fi
19313     fi
19314   fi
19315 
19316 
19317 # Check if pkg-config is available.
19318 
19319 
19320 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
19321         if test -n "$ac_tool_prefix"; then
19322   # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
19323 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
19324 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19325 $as_echo_n "checking for $ac_word... " >&6; }
19326 if ${ac_cv_path_PKG_CONFIG+:} false; then :
19327   $as_echo_n "(cached) " >&6
19328 else
19329   case $PKG_CONFIG in
19330   [\\/]* | ?:[\\/]*)
19331   ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
19332   ;;
19333   *)
19334   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19335 for as_dir in $PATH
19336 do
19337   IFS=$as_save_IFS
19338   test -z "$as_dir" && as_dir=.
19339     for ac_exec_ext in '' $ac_executable_extensions; do
19340   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19341     ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
19342     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19343     break 2
19344   fi
19345 done
19346   done
19347 IFS=$as_save_IFS
19348 
19349   ;;
19350 esac
19351 fi
19352 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
19353 if test -n "$PKG_CONFIG"; then
19354   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
19355 $as_echo "$PKG_CONFIG" >&6; }
19356 else
19357   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19358 $as_echo "no" >&6; }
19359 fi
19360 
19361 
19362 fi
19363 if test -z "$ac_cv_path_PKG_CONFIG"; then
19364   ac_pt_PKG_CONFIG=$PKG_CONFIG
19365   # Extract the first word of "pkg-config", so it can be a program name with args.
19366 set dummy pkg-config; ac_word=$2
19367 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19368 $as_echo_n "checking for $ac_word... " >&6; }
19369 if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
19370   $as_echo_n "(cached) " >&6
19371 else
19372   case $ac_pt_PKG_CONFIG in
19373   [\\/]* | ?:[\\/]*)
19374   ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
19375   ;;
19376   *)
19377   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19378 for as_dir in $PATH
19379 do
19380   IFS=$as_save_IFS
19381   test -z "$as_dir" && as_dir=.
19382     for ac_exec_ext in '' $ac_executable_extensions; do
19383   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19384     ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
19385     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19386     break 2
19387   fi
19388 done
19389   done
19390 IFS=$as_save_IFS
19391 
19392   ;;
19393 esac
19394 fi
19395 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
19396 if test -n "$ac_pt_PKG_CONFIG"; then
19397   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
19398 $as_echo "$ac_pt_PKG_CONFIG" >&6; }
19399 else
19400   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19401 $as_echo "no" >&6; }
19402 fi
19403 
19404   if test "x$ac_pt_PKG_CONFIG" = x; then
19405     PKG_CONFIG=""
19406   else
19407     case $cross_compiling:$ac_tool_warned in
19408 yes:)
19409 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
19410 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
19411 ac_tool_warned=yes ;;
19412 esac
19413     PKG_CONFIG=$ac_pt_PKG_CONFIG
19414   fi
19415 else
19416   PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
19417 fi
19418 
19419 fi
19420 if test -n "$PKG_CONFIG"; then
19421         _pkg_min_version=0.9.0
19422         { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
19423 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
19424         if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
19425                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19426 $as_echo "yes" >&6; }
19427         else
19428                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19429 $as_echo "no" >&6; }
19430                 PKG_CONFIG=""
19431         fi
19432 
19433 fi
19434 
19435 # After basic tools have been setup, we can check build os specific details.
19436 
19437   ###############################################################################
19438 
19439   # Note that this is the build platform OS version!
19440 
19441   OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`"
19442   OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`"
19443   OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`"
19444   OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`"
19445 
19446 
19447 
19448 
19449 
19450 # Setup builddeps, for automatic downloading of tools we need.
19451 # This is needed before we can call BDEPS_CHECK_MODULE, which is done in
19452 # boot-jdk setup, but we need to have basic tools setup first.
19453 
19454 
19455 # Check whether --with-builddeps-conf was given.
19456 if test "${with_builddeps_conf+set}" = set; then :
19457   withval=$with_builddeps_conf;
19458 fi
19459 
19460 
19461 
19462 # Check whether --with-builddeps-server was given.
19463 if test "${with_builddeps_server+set}" = set; then :
19464   withval=$with_builddeps_server;
19465 fi
19466 
19467 
19468 
19469 # Check whether --with-builddeps-dir was given.
19470 if test "${with_builddeps_dir+set}" = set; then :
19471   withval=$with_builddeps_dir;
19472 else
19473   with_builddeps_dir=/localhome/builddeps
19474 fi
19475 
19476 
19477 
19478 # Check whether --with-builddeps-group was given.
19479 if test "${with_builddeps_group+set}" = set; then :
19480   withval=$with_builddeps_group;
19481 fi
19482 
19483 
19484 
19485 
19486   if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
19487     if test "x$with_builddeps_conf" != x; then
19488       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for supplied builddeps configuration file" >&5
19489 $as_echo_n "checking for supplied builddeps configuration file... " >&6; }
19490       builddepsfile=$with_builddeps_conf
19491       if test -s $builddepsfile; then
19492         . $builddepsfile
19493         { $as_echo "$as_me:${as_lineno-$LINENO}: result: loaded!" >&5
19494 $as_echo "loaded!" >&6; }
19495       else
19496         as_fn_error $? "The given builddeps conf file $with_builddeps_conf could not be loaded!" "$LINENO" 5
19497       fi
19498     else
19499       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for builddeps.conf files in sources..." >&5
19500 $as_echo_n "checking for builddeps.conf files in sources...... " >&6; }
19501       builddepsfile=`mktemp`
19502       touch $builddepsfile
19503       # Put all found confs into a single file.
19504       find ${SRC_ROOT} -name builddeps.conf -exec cat \{\} \; >> $builddepsfile
19505       # Source the file to acquire the variables
19506       if test -s $builddepsfile; then
19507         . $builddepsfile
19508         { $as_echo "$as_me:${as_lineno-$LINENO}: result: found at least one!" >&5
19509 $as_echo "found at least one!" >&6; }
19510       else
19511         as_fn_error $? "Could not find any builddeps.conf at all!" "$LINENO" 5
19512       fi
19513     fi
19514     # Create build and target names that use _ instead of "-" and ".".
19515     # This is necessary to use them in variable names.
19516     build_var=`echo ${OPENJDK_BUILD_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19517     target_var=`echo ${OPENJDK_TARGET_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19518     # Extract rewrite information for build and target
19519     eval rewritten_build=\${REWRITE_${build_var}}
19520     if test "x$rewritten_build" = x; then
19521       rewritten_build=${OPENJDK_BUILD_AUTOCONF_NAME}
19522       echo Build stays the same $rewritten_build
19523     else
19524       echo Rewriting build for builddeps into $rewritten_build
19525     fi
19526     eval rewritten_target=\${REWRITE_${target_var}}
19527     if test "x$rewritten_target" = x; then
19528       rewritten_target=${OPENJDK_TARGET_AUTOCONF_NAME}
19529       echo Target stays the same $rewritten_target
19530     else
19531       echo Rewriting target for builddeps into $rewritten_target
19532     fi
19533     rewritten_build_var=`echo ${rewritten_build} | tr '-' '_' | tr '.' '_'`
19534     rewritten_target_var=`echo ${rewritten_target} | tr '-' '_' | tr '.' '_'`
19535   fi
19536   for ac_prog in 7z unzip
19537 do
19538   # Extract the first word of "$ac_prog", so it can be a program name with args.
19539 set dummy $ac_prog; ac_word=$2
19540 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19541 $as_echo_n "checking for $ac_word... " >&6; }
19542 if ${ac_cv_prog_BDEPS_UNZIP+:} false; then :
19543   $as_echo_n "(cached) " >&6
19544 else
19545   if test -n "$BDEPS_UNZIP"; then
19546   ac_cv_prog_BDEPS_UNZIP="$BDEPS_UNZIP" # Let the user override the test.
19547 else
19548 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19549 for as_dir in $PATH
19550 do
19551   IFS=$as_save_IFS
19552   test -z "$as_dir" && as_dir=.
19553     for ac_exec_ext in '' $ac_executable_extensions; do
19554   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19555     ac_cv_prog_BDEPS_UNZIP="$ac_prog"
19556     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19557     break 2
19558   fi
19559 done
19560   done
19561 IFS=$as_save_IFS
19562 
19563 fi
19564 fi
19565 BDEPS_UNZIP=$ac_cv_prog_BDEPS_UNZIP
19566 if test -n "$BDEPS_UNZIP"; then
19567   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_UNZIP" >&5
19568 $as_echo "$BDEPS_UNZIP" >&6; }
19569 else
19570   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19571 $as_echo "no" >&6; }
19572 fi
19573 
19574 
19575   test -n "$BDEPS_UNZIP" && break
19576 done
19577 
19578   if test "x$BDEPS_UNZIP" = x7z; then
19579     BDEPS_UNZIP="7z x"
19580   fi
19581 
19582   for ac_prog in wget lftp ftp
19583 do
19584   # Extract the first word of "$ac_prog", so it can be a program name with args.
19585 set dummy $ac_prog; ac_word=$2
19586 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19587 $as_echo_n "checking for $ac_word... " >&6; }
19588 if ${ac_cv_prog_BDEPS_FTP+:} false; then :
19589   $as_echo_n "(cached) " >&6
19590 else
19591   if test -n "$BDEPS_FTP"; then
19592   ac_cv_prog_BDEPS_FTP="$BDEPS_FTP" # Let the user override the test.
19593 else
19594 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19595 for as_dir in $PATH
19596 do
19597   IFS=$as_save_IFS
19598   test -z "$as_dir" && as_dir=.
19599     for ac_exec_ext in '' $ac_executable_extensions; do
19600   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19601     ac_cv_prog_BDEPS_FTP="$ac_prog"
19602     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19603     break 2
19604   fi
19605 done
19606   done
19607 IFS=$as_save_IFS
19608 
19609 fi
19610 fi
19611 BDEPS_FTP=$ac_cv_prog_BDEPS_FTP
19612 if test -n "$BDEPS_FTP"; then
19613   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_FTP" >&5
19614 $as_echo "$BDEPS_FTP" >&6; }
19615 else
19616   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19617 $as_echo "no" >&6; }
19618 fi
19619 
19620 
19621   test -n "$BDEPS_FTP" && break
19622 done
19623 
19624 
19625 
19626 ###############################################################################
19627 #
19628 # Determine OpenJDK variants, options and version numbers.
19629 #
19630 ###############################################################################
19631 
19632 # We need build & target for this.
19633 
19634 
19635   ###############################################################################
19636   #
19637   # Should we build a JDK/JVM with headful support (ie a graphical ui)?
19638   # We always build headless support.
19639   #
19640   { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
19641 $as_echo_n "checking headful support... " >&6; }
19642   # Check whether --enable-headful was given.
19643 if test "${enable_headful+set}" = set; then :
19644   enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
19645 else
19646   SUPPORT_HEADFUL=yes
19647 fi
19648 
19649 
19650   SUPPORT_HEADLESS=yes
19651   BUILD_HEADLESS="BUILD_HEADLESS:=true"
19652 
19653   if test "x$SUPPORT_HEADFUL" = xyes; then
19654     # We are building both headful and headless.
19655     headful_msg="include support for both headful and headless"
19656   fi
19657 
19658   if test "x$SUPPORT_HEADFUL" = xno; then
19659     # Thus we are building headless only.
19660     BUILD_HEADLESS="BUILD_HEADLESS:=true"
19661     headful_msg="headless only"
19662   fi
19663 
19664   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
19665 $as_echo "$headful_msg" >&6; }
19666 
19667 
19668 
19669 
19670 
19671   # Control wether Hotspot runs Queens test after build.
19672   # Check whether --enable-hotspot-test-in-build was given.
19673 if test "${enable_hotspot_test_in_build+set}" = set; then :
19674   enableval=$enable_hotspot_test_in_build;
19675 else
19676   enable_hotspot_test_in_build=no
19677 fi
19678 
19679   if test "x$enable_hotspot_test_in_build" = "xyes"; then
19680     TEST_IN_BUILD=true
19681   else
19682     TEST_IN_BUILD=false
19683   fi
19684 
19685 
19686   ###############################################################################
19687   #
19688   # Choose cacerts source file
19689   #
19690 
19691 # Check whether --with-cacerts-file was given.
19692 if test "${with_cacerts_file+set}" = set; then :
19693   withval=$with_cacerts_file;
19694 fi
19695 
19696   if test "x$with_cacerts_file" != x; then
19697     CACERTS_FILE=$with_cacerts_file
19698   else
19699     CACERTS_FILE=${SRC_ROOT}/jdk/src/share/lib/security/cacerts
19700   fi
19701 
19702 
19703   ###############################################################################
19704   #
19705   # Enable or disable unlimited crypto
19706   #
19707   # Check whether --enable-unlimited-crypto was given.
19708 if test "${enable_unlimited_crypto+set}" = set; then :
19709   enableval=$enable_unlimited_crypto;
19710 else
19711   enable_unlimited_crypto=no
19712 fi
19713 
19714   if test "x$enable_unlimited_crypto" = "xyes"; then
19715     UNLIMITED_CRYPTO=true
19716   else
19717     UNLIMITED_CRYPTO=false
19718   fi
19719 
19720 
19721   ###############################################################################
19722   #
19723   # Enable or disable the elliptic curve crypto implementation
19724   #
19725 
19726 
19727   ###############################################################################
19728   #
19729   # --enable-rmiconnector-iiop
19730   #
19731   # Check whether --enable-rmiconnector-iiop was given.
19732 if test "${enable_rmiconnector_iiop+set}" = set; then :
19733   enableval=$enable_rmiconnector_iiop;
19734 fi
19735 
19736   if test "x$enable_rmiconnector_iiop" = "xyes"; then
19737     RMICONNECTOR_IIOP=true
19738   else
19739     RMICONNECTOR_IIOP=false
19740   fi
19741 
19742 
19743   ###############################################################################
19744   #
19745   # Compress jars
19746   #
19747   COMPRESS_JARS=false
19748 
19749 
19750 
19751 
19752   # Source the version numbers
19753   . $AUTOCONF_DIR/version-numbers
19754 
19755   # Get the settings from parameters
19756 
19757 # Check whether --with-milestone was given.
19758 if test "${with_milestone+set}" = set; then :
19759   withval=$with_milestone;
19760 fi
19761 
19762   if test "x$with_milestone" = xyes; then
19763     as_fn_error $? "Milestone must have a value" "$LINENO" 5
19764   elif test "x$with_milestone" != x; then
19765     MILESTONE="$with_milestone"
19766   fi
19767   if test "x$MILESTONE" = x; then
19768     MILESTONE=internal
19769   fi
19770 
19771 
19772 # Check whether --with-update-version was given.
19773 if test "${with_update_version+set}" = set; then :
19774   withval=$with_update_version;
19775 fi
19776 
19777   if test "x$with_update_version" = xyes; then
19778     as_fn_error $? "Update version must have a value" "$LINENO" 5
19779   elif test "x$with_update_version" != x; then
19780     JDK_UPDATE_VERSION="$with_update_version"
19781     # On macosx 10.7, it's not possible to set --with-update-version=0X due
19782     # to a bug in expr (which reduces it to just X). To work around this, we
19783     # always add a 0 to one digit update versions.
19784     if test "${#JDK_UPDATE_VERSION}" = "1"; then
19785       JDK_UPDATE_VERSION="0${JDK_UPDATE_VERSION}"
19786     fi
19787   fi
19788 
19789 
19790 # Check whether --with-user-release-suffix was given.
19791 if test "${with_user_release_suffix+set}" = set; then :
19792   withval=$with_user_release_suffix;
19793 fi
19794 
19795   if test "x$with_user_release_suffix" = xyes; then
19796     as_fn_error $? "Release suffix must have a value" "$LINENO" 5
19797   elif test "x$with_user_release_suffix" != x; then
19798     USER_RELEASE_SUFFIX="$with_user_release_suffix"
19799   fi
19800 
19801 
19802 # Check whether --with-build-number was given.
19803 if test "${with_build_number+set}" = set; then :
19804   withval=$with_build_number;
19805 fi
19806 
19807   if test "x$with_build_number" = xyes; then
19808     as_fn_error $? "Build number must have a value" "$LINENO" 5
19809   elif test "x$with_build_number" != x; then
19810     JDK_BUILD_NUMBER="$with_build_number"
19811   fi
19812   # Define default USER_RELEASE_SUFFIX if BUILD_NUMBER and USER_RELEASE_SUFFIX are not set
19813   if test "x$JDK_BUILD_NUMBER" = x; then
19814     JDK_BUILD_NUMBER=b00
19815     if test "x$USER_RELEASE_SUFFIX" = x; then
19816       BUILD_DATE=`date '+%Y_%m_%d_%H_%M'`
19817       # Avoid [:alnum:] since it depends on the locale.
19818       CLEAN_USERNAME=`echo "$USER" | $TR -d -c 'abcdefghijklmnopqrstuvqxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'`
19819       USER_RELEASE_SUFFIX=`echo "${CLEAN_USERNAME}_${BUILD_DATE}" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19820     fi
19821   fi
19822 
19823   # Now set the JDK version, milestone, build number etc.
19824 
19825 
19826 
19827 
19828 
19829 
19830 
19831 
19832 
19833 
19834 
19835 
19836 
19837 
19838 
19839   COPYRIGHT_YEAR=`date +'%Y'`
19840 
19841 
19842   if test "x$JDK_UPDATE_VERSION" != x; then
19843     JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}_${JDK_UPDATE_VERSION}"
19844   else
19845     JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}"
19846   fi
19847 
19848 
19849   COOKED_BUILD_NUMBER=`$ECHO $JDK_BUILD_NUMBER | $SED -e 's/^b//' -e 's/^0//'`
19850 
19851 
19852 
19853 ###############################################################################
19854 #
19855 # Setup BootJDK, used to bootstrap the build.
19856 #
19857 ###############################################################################
19858 
19859 
19860   BOOT_JDK_FOUND=no
19861 
19862 # Check whether --with-boot-jdk was given.
19863 if test "${with_boot_jdk+set}" = set; then :
19864   withval=$with_boot_jdk;
19865 fi
19866 
19867 
19868   # We look for the Boot JDK through various means, going from more certain to
19869   # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
19870   # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
19871   # must check if this is indeed valid; otherwise we'll continue looking.
19872 
19873   # Test: Is bootjdk explicitely set by command line arguments?
19874 
19875   if test "x$BOOT_JDK_FOUND" = xno; then
19876     # Now execute the test
19877 
19878   if test "x$with_boot_jdk" != x; then
19879     BOOT_JDK=$with_boot_jdk
19880     BOOT_JDK_FOUND=maybe
19881     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
19882 $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
19883   fi
19884 
19885 
19886     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
19887     if test "x$BOOT_JDK_FOUND" = xmaybe; then
19888       # Do we have a bin/java?
19889       if test ! -x "$BOOT_JDK/bin/java"; then
19890         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
19891 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
19892         BOOT_JDK_FOUND=no
19893       else
19894         # Do we have a bin/javac?
19895         if test ! -x "$BOOT_JDK/bin/javac"; then
19896           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
19897 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
19898           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
19899 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
19900           BOOT_JDK_FOUND=no
19901         else
19902           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
19903           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
19904             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
19905 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
19906             BOOT_JDK_FOUND=no
19907           else
19908             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
19909             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
19910 
19911             # Extra M4 quote needed to protect [] in grep expression.
19912             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
19913             if test "x$FOUND_CORRECT_VERSION" = x; then
19914               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
19915 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
19916               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
19917 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
19918               BOOT_JDK_FOUND=no
19919             else
19920               # We're done! :-)
19921               BOOT_JDK_FOUND=yes
19922 
19923   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19924 
19925   # Input might be given as Windows format, start by converting to
19926   # unix format.
19927   path="$BOOT_JDK"
19928   new_path=`$CYGPATH -u "$path"`
19929 
19930   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19931   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19932   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19933   # "foo.exe" is OK but "foo" is an error.
19934   #
19935   # This test is therefore slightly more accurate than "test -f" to check for file precense.
19936   # It is also a way to make sure we got the proper file name for the real test later on.
19937   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19938   if test "x$test_shortpath" = x; then
19939     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
19940 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
19941     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
19942   fi
19943 
19944   # Call helper function which possibly converts this using DOS-style short mode.
19945   # If so, the updated path is stored in $new_path.
19946 
19947   input_path="$new_path"
19948   # Check if we need to convert this using DOS-style short mode. If the path
19949   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19950   # take no chances and rewrite it.
19951   # Note: m4 eats our [], so we need to use [ and ] instead.
19952   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19953   if test "x$has_forbidden_chars" != x; then
19954     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19955     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19956     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19957     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19958       # Going to short mode and back again did indeed matter. Since short mode is
19959       # case insensitive, let's make it lowercase to improve readability.
19960       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19961       # Now convert it back to Unix-stile (cygpath)
19962       input_path=`$CYGPATH -u "$shortmode_path"`
19963       new_path="$input_path"
19964     fi
19965   fi
19966 
19967   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19968   if test "x$test_cygdrive_prefix" = x; then
19969     # As a simple fix, exclude /usr/bin since it's not a real path.
19970     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
19971       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19972       # a path prefixed by /cygdrive for fixpath to work.
19973       new_path="$CYGWIN_ROOT_PATH$input_path"
19974     fi
19975   fi
19976 
19977 
19978   if test "x$path" != "x$new_path"; then
19979     BOOT_JDK="$new_path"
19980     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
19981 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
19982   fi
19983 
19984   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19985 
19986   path="$BOOT_JDK"
19987   has_colon=`$ECHO $path | $GREP ^.:`
19988   new_path="$path"
19989   if test "x$has_colon" = x; then
19990     # Not in mixed or Windows style, start by that.
19991     new_path=`cmd //c echo $path`
19992   fi
19993 
19994 
19995   input_path="$new_path"
19996   # Check if we need to convert this using DOS-style short mode. If the path
19997   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19998   # take no chances and rewrite it.
19999   # Note: m4 eats our [], so we need to use [ and ] instead.
20000   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20001   if test "x$has_forbidden_chars" != x; then
20002     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20003     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20004   fi
20005 
20006 
20007   windows_path="$new_path"
20008   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20009     unix_path=`$CYGPATH -u "$windows_path"`
20010     new_path="$unix_path"
20011   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20012     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20013     new_path="$unix_path"
20014   fi
20015 
20016   if test "x$path" != "x$new_path"; then
20017     BOOT_JDK="$new_path"
20018     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20019 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20020   fi
20021 
20022   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20023   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20024 
20025   else
20026     # We're on a posix platform. Hooray! :)
20027     path="$BOOT_JDK"
20028     has_space=`$ECHO "$path" | $GREP " "`
20029     if test "x$has_space" != x; then
20030       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20031 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20032       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20033     fi
20034 
20035     # Use eval to expand a potential ~
20036     eval path="$path"
20037     if test ! -f "$path" && test ! -d "$path"; then
20038       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20039     fi
20040 
20041     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20042   fi
20043 
20044               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20045 $as_echo_n "checking for Boot JDK... " >&6; }
20046               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20047 $as_echo "$BOOT_JDK" >&6; }
20048               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20049 $as_echo_n "checking Boot JDK version... " >&6; }
20050               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20051               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20052 $as_echo "$BOOT_JDK_VERSION" >&6; }
20053             fi # end check jdk version
20054           fi # end check rt.jar
20055         fi # end check javac
20056       fi # end check java
20057     fi # end check boot jdk found
20058   fi
20059 
20060   if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
20061     # Having specified an argument which is incorrect will produce an instant failure;
20062     # we should not go on looking
20063     as_fn_error $? "The path given by --with-boot-jdk does not contain a valid Boot JDK" "$LINENO" 5
20064   fi
20065 
20066   # Test: Is bootjdk available from builddeps?
20067 
20068   if test "x$BOOT_JDK_FOUND" = xno; then
20069     # Now execute the test
20070 
20071 
20072 
20073   if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
20074     # Source the builddeps file again, to make sure it uses the latest variables!
20075     . $builddepsfile
20076     # Look for a target and build machine specific resource!
20077     eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}_TARGET_${rewritten_target_var}}
20078     if test "x$resource" = x; then
20079       # Ok, lets instead look for a target specific resource
20080       eval resource=\${builddep_bootjdk_TARGET_${rewritten_target_var}}
20081     fi
20082     if test "x$resource" = x; then
20083       # Ok, lets instead look for a build specific resource
20084       eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}}
20085     fi
20086     if test "x$resource" = x; then
20087       # Ok, lets instead look for a generic resource
20088       # (The bootjdk comes from M4 and not the shell, thus no need for eval here.)
20089       resource=${builddep_bootjdk}
20090     fi
20091     if test "x$resource" != x; then
20092       { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for bootjdk" >&5
20093 $as_echo "$as_me: Using builddeps $resource for bootjdk" >&6;}
20094       # If the resource in the builddeps.conf file is an existing directory,
20095       # for example /java/linux/cups
20096       if test -d ${resource}; then
20097         depdir=${resource}
20098       else
20099 
20100   # bootjdk is for example mymodule
20101   # $resource is for example libs/general/libmymod_1_2_3.zip
20102   # $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps
20103   # $with_builddeps_dir is for example /localhome/builddeps
20104   # depdir is the name of the variable into which we store the depdir, eg MYMOD
20105   # Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and
20106   # unzip into the directory: /localhome/builddeps/libmymod_1_2_3
20107   filename=`basename $resource`
20108   filebase=`echo $filename | sed 's/\.[^\.]*$//'`
20109   filebase=${filename%%.*}
20110   extension=${filename#*.}
20111   installdir=$with_builddeps_dir/$filebase
20112   if test ! -f $installdir/$filename.unpacked; then
20113     { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&5
20114 $as_echo "$as_me: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&6;}
20115     if test ! -d $installdir; then
20116       mkdir -p $installdir
20117     fi
20118     if test ! -d $installdir; then
20119       as_fn_error $? "Could not create directory $installdir" "$LINENO" 5
20120     fi
20121     tmpfile=`mktemp $installdir/bootjdk.XXXXXXXXX`
20122     touch $tmpfile
20123     if test ! -f $tmpfile; then
20124       as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5
20125     fi
20126 
20127   # $with_builddeps_server/$resource  is the ftp://abuilddeps.server.com/libs/cups.zip
20128   # $tmpfile is the local file name for the downloaded file.
20129   VALID_TOOL=no
20130   if test "x$BDEPS_FTP" = xwget; then
20131     VALID_TOOL=yes
20132     wget -O $tmpfile $with_builddeps_server/$resource
20133   fi
20134   if test "x$BDEPS_FTP" = xlftp; then
20135     VALID_TOOL=yes
20136     lftp -c "get $with_builddeps_server/$resource  -o $tmpfile"
20137   fi
20138   if test "x$BDEPS_FTP" = xftp; then
20139     VALID_TOOL=yes
20140     FTPSERVER=`echo $with_builddeps_server/$resource  | cut -f 3 -d '/'`
20141     FTPPATH=`echo $with_builddeps_server/$resource  | cut -f 4- -d '/'`
20142     FTPUSERPWD=${FTPSERVER%%@*}
20143     if test "x$FTPSERVER" != "x$FTPUSERPWD"; then
20144       FTPUSER=${userpwd%%:*}
20145       FTPPWD=${userpwd#*@}
20146       FTPSERVER=${FTPSERVER#*@}
20147     else
20148       FTPUSER=ftp
20149       FTPPWD=ftp
20150     fi
20151     # the "pass" command does not work on some
20152     # ftp clients (read ftp.exe) but if it works,
20153     # passive mode is better!
20154     ( \
20155         echo "user $FTPUSER $FTPPWD"        ; \
20156         echo "pass"                         ; \
20157         echo "bin"                          ; \
20158         echo "get $FTPPATH $tmpfile"              ; \
20159     ) | ftp -in $FTPSERVER
20160   fi
20161   if test "x$VALID_TOOL" != xyes; then
20162     as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5
20163   fi
20164 
20165     mv $tmpfile $installdir/$filename
20166     if test ! -s $installdir/$filename; then
20167       as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5
20168     fi
20169     case "$extension" in
20170       zip)  echo "Unzipping $installdir/$filename..."
20171         (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked)
20172         ;;
20173       tar.gz) echo "Untaring $installdir/$filename..."
20174         (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
20175         ;;
20176       tgz) echo "Untaring $installdir/$filename..."
20177         (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
20178         ;;
20179       *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5
20180         ;;
20181     esac
20182   fi
20183   if test -f $installdir/$filename.unpacked; then
20184     depdir=$installdir
20185   fi
20186 
20187       fi
20188       # Source the builddeps file again, because in the previous command, the depdir
20189       # was updated to point at the current build dependency install directory.
20190       . $builddepsfile
20191       # Now extract variables from the builddeps.conf files.
20192       theroot=${builddep_bootjdk_ROOT}
20193       thecflags=${builddep_bootjdk_CFLAGS}
20194       thelibs=${builddep_bootjdk_LIBS}
20195       if test "x$depdir" = x; then
20196         as_fn_error $? "Could not download build dependency bootjdk" "$LINENO" 5
20197       fi
20198       BOOT_JDK=$depdir
20199       if test "x$theroot" != x; then
20200         BOOT_JDK="$theroot"
20201       fi
20202       if test "x$thecflags" != x; then
20203         BOOT_JDK_CFLAGS="$thecflags"
20204       fi
20205       if test "x$thelibs" != x; then
20206         BOOT_JDK_LIBS="$thelibs"
20207       fi
20208       BOOT_JDK_FOUND=maybe
20209       else BOOT_JDK_FOUND=no
20210 
20211     fi
20212     else BOOT_JDK_FOUND=no
20213 
20214   fi
20215 
20216 
20217 
20218     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20219     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20220       # Do we have a bin/java?
20221       if test ! -x "$BOOT_JDK/bin/java"; then
20222         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20223 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20224         BOOT_JDK_FOUND=no
20225       else
20226         # Do we have a bin/javac?
20227         if test ! -x "$BOOT_JDK/bin/javac"; then
20228           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20229 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20230           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20231 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20232           BOOT_JDK_FOUND=no
20233         else
20234           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20235           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20236             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20237 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20238             BOOT_JDK_FOUND=no
20239           else
20240             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20241             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20242 
20243             # Extra M4 quote needed to protect [] in grep expression.
20244             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
20245             if test "x$FOUND_CORRECT_VERSION" = x; then
20246               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20247 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20248               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20249 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20250               BOOT_JDK_FOUND=no
20251             else
20252               # We're done! :-)
20253               BOOT_JDK_FOUND=yes
20254 
20255   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20256 
20257   # Input might be given as Windows format, start by converting to
20258   # unix format.
20259   path="$BOOT_JDK"
20260   new_path=`$CYGPATH -u "$path"`
20261 
20262   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20263   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20264   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20265   # "foo.exe" is OK but "foo" is an error.
20266   #
20267   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20268   # It is also a way to make sure we got the proper file name for the real test later on.
20269   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20270   if test "x$test_shortpath" = x; then
20271     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20272 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20273     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20274   fi
20275 
20276   # Call helper function which possibly converts this using DOS-style short mode.
20277   # If so, the updated path is stored in $new_path.
20278 
20279   input_path="$new_path"
20280   # Check if we need to convert this using DOS-style short mode. If the path
20281   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20282   # take no chances and rewrite it.
20283   # Note: m4 eats our [], so we need to use [ and ] instead.
20284   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20285   if test "x$has_forbidden_chars" != x; then
20286     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20287     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20288     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20289     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20290       # Going to short mode and back again did indeed matter. Since short mode is
20291       # case insensitive, let's make it lowercase to improve readability.
20292       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20293       # Now convert it back to Unix-stile (cygpath)
20294       input_path=`$CYGPATH -u "$shortmode_path"`
20295       new_path="$input_path"
20296     fi
20297   fi
20298 
20299   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20300   if test "x$test_cygdrive_prefix" = x; then
20301     # As a simple fix, exclude /usr/bin since it's not a real path.
20302     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20303       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20304       # a path prefixed by /cygdrive for fixpath to work.
20305       new_path="$CYGWIN_ROOT_PATH$input_path"
20306     fi
20307   fi
20308 
20309 
20310   if test "x$path" != "x$new_path"; then
20311     BOOT_JDK="$new_path"
20312     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20313 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20314   fi
20315 
20316   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20317 
20318   path="$BOOT_JDK"
20319   has_colon=`$ECHO $path | $GREP ^.:`
20320   new_path="$path"
20321   if test "x$has_colon" = x; then
20322     # Not in mixed or Windows style, start by that.
20323     new_path=`cmd //c echo $path`
20324   fi
20325 
20326 
20327   input_path="$new_path"
20328   # Check if we need to convert this using DOS-style short mode. If the path
20329   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20330   # take no chances and rewrite it.
20331   # Note: m4 eats our [], so we need to use [ and ] instead.
20332   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20333   if test "x$has_forbidden_chars" != x; then
20334     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20335     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20336   fi
20337 
20338 
20339   windows_path="$new_path"
20340   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20341     unix_path=`$CYGPATH -u "$windows_path"`
20342     new_path="$unix_path"
20343   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20344     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20345     new_path="$unix_path"
20346   fi
20347 
20348   if test "x$path" != "x$new_path"; then
20349     BOOT_JDK="$new_path"
20350     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20351 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20352   fi
20353 
20354   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20355   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20356 
20357   else
20358     # We're on a posix platform. Hooray! :)
20359     path="$BOOT_JDK"
20360     has_space=`$ECHO "$path" | $GREP " "`
20361     if test "x$has_space" != x; then
20362       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20363 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20364       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20365     fi
20366 
20367     # Use eval to expand a potential ~
20368     eval path="$path"
20369     if test ! -f "$path" && test ! -d "$path"; then
20370       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20371     fi
20372 
20373     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20374   fi
20375 
20376               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20377 $as_echo_n "checking for Boot JDK... " >&6; }
20378               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20379 $as_echo "$BOOT_JDK" >&6; }
20380               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20381 $as_echo_n "checking Boot JDK version... " >&6; }
20382               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20383               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20384 $as_echo "$BOOT_JDK_VERSION" >&6; }
20385             fi # end check jdk version
20386           fi # end check rt.jar
20387         fi # end check javac
20388       fi # end check java
20389     fi # end check boot jdk found
20390   fi
20391 
20392 
20393   # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
20394 
20395   if test "x$BOOT_JDK_FOUND" = xno; then
20396     # Now execute the test
20397 
20398   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
20399     # First check at user selected default
20400 
20401   if test "x$BOOT_JDK_FOUND" = xno; then
20402     # Now execute the test
20403 
20404   if test -x /usr/libexec/java_home; then
20405     BOOT_JDK=`/usr/libexec/java_home `
20406     BOOT_JDK_FOUND=maybe
20407     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home " >&5
20408 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home " >&6;}
20409   fi
20410 
20411 
20412     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20413     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20414       # Do we have a bin/java?
20415       if test ! -x "$BOOT_JDK/bin/java"; then
20416         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20417 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20418         BOOT_JDK_FOUND=no
20419       else
20420         # Do we have a bin/javac?
20421         if test ! -x "$BOOT_JDK/bin/javac"; then
20422           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20423 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20424           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20425 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20426           BOOT_JDK_FOUND=no
20427         else
20428           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20429           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20430             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20431 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20432             BOOT_JDK_FOUND=no
20433           else
20434             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20435             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20436 
20437             # Extra M4 quote needed to protect [] in grep expression.
20438             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
20439             if test "x$FOUND_CORRECT_VERSION" = x; then
20440               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20441 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20442               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20443 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20444               BOOT_JDK_FOUND=no
20445             else
20446               # We're done! :-)
20447               BOOT_JDK_FOUND=yes
20448 
20449   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20450 
20451   # Input might be given as Windows format, start by converting to
20452   # unix format.
20453   path="$BOOT_JDK"
20454   new_path=`$CYGPATH -u "$path"`
20455 
20456   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20457   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20458   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20459   # "foo.exe" is OK but "foo" is an error.
20460   #
20461   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20462   # It is also a way to make sure we got the proper file name for the real test later on.
20463   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20464   if test "x$test_shortpath" = x; then
20465     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20466 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20467     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20468   fi
20469 
20470   # Call helper function which possibly converts this using DOS-style short mode.
20471   # If so, the updated path is stored in $new_path.
20472 
20473   input_path="$new_path"
20474   # Check if we need to convert this using DOS-style short mode. If the path
20475   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20476   # take no chances and rewrite it.
20477   # Note: m4 eats our [], so we need to use [ and ] instead.
20478   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20479   if test "x$has_forbidden_chars" != x; then
20480     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20481     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20482     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20483     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20484       # Going to short mode and back again did indeed matter. Since short mode is
20485       # case insensitive, let's make it lowercase to improve readability.
20486       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20487       # Now convert it back to Unix-stile (cygpath)
20488       input_path=`$CYGPATH -u "$shortmode_path"`
20489       new_path="$input_path"
20490     fi
20491   fi
20492 
20493   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20494   if test "x$test_cygdrive_prefix" = x; then
20495     # As a simple fix, exclude /usr/bin since it's not a real path.
20496     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20497       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20498       # a path prefixed by /cygdrive for fixpath to work.
20499       new_path="$CYGWIN_ROOT_PATH$input_path"
20500     fi
20501   fi
20502 
20503 
20504   if test "x$path" != "x$new_path"; then
20505     BOOT_JDK="$new_path"
20506     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20507 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20508   fi
20509 
20510   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20511 
20512   path="$BOOT_JDK"
20513   has_colon=`$ECHO $path | $GREP ^.:`
20514   new_path="$path"
20515   if test "x$has_colon" = x; then
20516     # Not in mixed or Windows style, start by that.
20517     new_path=`cmd //c echo $path`
20518   fi
20519 
20520 
20521   input_path="$new_path"
20522   # Check if we need to convert this using DOS-style short mode. If the path
20523   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20524   # take no chances and rewrite it.
20525   # Note: m4 eats our [], so we need to use [ and ] instead.
20526   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20527   if test "x$has_forbidden_chars" != x; then
20528     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20529     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20530   fi
20531 
20532 
20533   windows_path="$new_path"
20534   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20535     unix_path=`$CYGPATH -u "$windows_path"`
20536     new_path="$unix_path"
20537   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20538     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20539     new_path="$unix_path"
20540   fi
20541 
20542   if test "x$path" != "x$new_path"; then
20543     BOOT_JDK="$new_path"
20544     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20545 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20546   fi
20547 
20548   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20549   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20550 
20551   else
20552     # We're on a posix platform. Hooray! :)
20553     path="$BOOT_JDK"
20554     has_space=`$ECHO "$path" | $GREP " "`
20555     if test "x$has_space" != x; then
20556       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20557 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20558       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20559     fi
20560 
20561     # Use eval to expand a potential ~
20562     eval path="$path"
20563     if test ! -f "$path" && test ! -d "$path"; then
20564       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20565     fi
20566 
20567     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20568   fi
20569 
20570               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20571 $as_echo_n "checking for Boot JDK... " >&6; }
20572               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20573 $as_echo "$BOOT_JDK" >&6; }
20574               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20575 $as_echo_n "checking Boot JDK version... " >&6; }
20576               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20577               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20578 $as_echo "$BOOT_JDK_VERSION" >&6; }
20579             fi # end check jdk version
20580           fi # end check rt.jar
20581         fi # end check javac
20582       fi # end check java
20583     fi # end check boot jdk found
20584   fi
20585 
20586     # If that did not work out (e.g. too old), try explicit versions instead
20587 
20588   if test "x$BOOT_JDK_FOUND" = xno; then
20589     # Now execute the test
20590 
20591   if test -x /usr/libexec/java_home; then
20592     BOOT_JDK=`/usr/libexec/java_home -v 1.9`
20593     BOOT_JDK_FOUND=maybe
20594     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&5
20595 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&6;}
20596   fi
20597 
20598 
20599     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20600     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20601       # Do we have a bin/java?
20602       if test ! -x "$BOOT_JDK/bin/java"; then
20603         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20604 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20605         BOOT_JDK_FOUND=no
20606       else
20607         # Do we have a bin/javac?
20608         if test ! -x "$BOOT_JDK/bin/javac"; then
20609           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20610 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20611           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20612 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20613           BOOT_JDK_FOUND=no
20614         else
20615           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20616           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20617             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20618 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20619             BOOT_JDK_FOUND=no
20620           else
20621             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20622             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20623 
20624             # Extra M4 quote needed to protect [] in grep expression.
20625             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
20626             if test "x$FOUND_CORRECT_VERSION" = x; then
20627               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20628 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20629               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20630 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20631               BOOT_JDK_FOUND=no
20632             else
20633               # We're done! :-)
20634               BOOT_JDK_FOUND=yes
20635 
20636   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20637 
20638   # Input might be given as Windows format, start by converting to
20639   # unix format.
20640   path="$BOOT_JDK"
20641   new_path=`$CYGPATH -u "$path"`
20642 
20643   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20644   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20645   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20646   # "foo.exe" is OK but "foo" is an error.
20647   #
20648   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20649   # It is also a way to make sure we got the proper file name for the real test later on.
20650   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20651   if test "x$test_shortpath" = x; then
20652     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20653 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20654     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20655   fi
20656 
20657   # Call helper function which possibly converts this using DOS-style short mode.
20658   # If so, the updated path is stored in $new_path.
20659 
20660   input_path="$new_path"
20661   # Check if we need to convert this using DOS-style short mode. If the path
20662   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20663   # take no chances and rewrite it.
20664   # Note: m4 eats our [], so we need to use [ and ] instead.
20665   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20666   if test "x$has_forbidden_chars" != x; then
20667     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20668     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20669     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20670     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20671       # Going to short mode and back again did indeed matter. Since short mode is
20672       # case insensitive, let's make it lowercase to improve readability.
20673       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20674       # Now convert it back to Unix-stile (cygpath)
20675       input_path=`$CYGPATH -u "$shortmode_path"`
20676       new_path="$input_path"
20677     fi
20678   fi
20679 
20680   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20681   if test "x$test_cygdrive_prefix" = x; then
20682     # As a simple fix, exclude /usr/bin since it's not a real path.
20683     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20684       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20685       # a path prefixed by /cygdrive for fixpath to work.
20686       new_path="$CYGWIN_ROOT_PATH$input_path"
20687     fi
20688   fi
20689 
20690 
20691   if test "x$path" != "x$new_path"; then
20692     BOOT_JDK="$new_path"
20693     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20694 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20695   fi
20696 
20697   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20698 
20699   path="$BOOT_JDK"
20700   has_colon=`$ECHO $path | $GREP ^.:`
20701   new_path="$path"
20702   if test "x$has_colon" = x; then
20703     # Not in mixed or Windows style, start by that.
20704     new_path=`cmd //c echo $path`
20705   fi
20706 
20707 
20708   input_path="$new_path"
20709   # Check if we need to convert this using DOS-style short mode. If the path
20710   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20711   # take no chances and rewrite it.
20712   # Note: m4 eats our [], so we need to use [ and ] instead.
20713   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20714   if test "x$has_forbidden_chars" != x; then
20715     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20716     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20717   fi
20718 
20719 
20720   windows_path="$new_path"
20721   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20722     unix_path=`$CYGPATH -u "$windows_path"`
20723     new_path="$unix_path"
20724   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20725     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20726     new_path="$unix_path"
20727   fi
20728 
20729   if test "x$path" != "x$new_path"; then
20730     BOOT_JDK="$new_path"
20731     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20732 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20733   fi
20734 
20735   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20736   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20737 
20738   else
20739     # We're on a posix platform. Hooray! :)
20740     path="$BOOT_JDK"
20741     has_space=`$ECHO "$path" | $GREP " "`
20742     if test "x$has_space" != x; then
20743       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20744 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20745       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20746     fi
20747 
20748     # Use eval to expand a potential ~
20749     eval path="$path"
20750     if test ! -f "$path" && test ! -d "$path"; then
20751       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20752     fi
20753 
20754     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20755   fi
20756 
20757               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20758 $as_echo_n "checking for Boot JDK... " >&6; }
20759               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20760 $as_echo "$BOOT_JDK" >&6; }
20761               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20762 $as_echo_n "checking Boot JDK version... " >&6; }
20763               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20764               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20765 $as_echo "$BOOT_JDK_VERSION" >&6; }
20766             fi # end check jdk version
20767           fi # end check rt.jar
20768         fi # end check javac
20769       fi # end check java
20770     fi # end check boot jdk found
20771   fi
20772 
20773 
20774   if test "x$BOOT_JDK_FOUND" = xno; then
20775     # Now execute the test
20776 
20777   if test -x /usr/libexec/java_home; then
20778     BOOT_JDK=`/usr/libexec/java_home -v 1.8`
20779     BOOT_JDK_FOUND=maybe
20780     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&5
20781 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&6;}
20782   fi
20783 
20784 
20785     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20786     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20787       # Do we have a bin/java?
20788       if test ! -x "$BOOT_JDK/bin/java"; then
20789         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20790 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20791         BOOT_JDK_FOUND=no
20792       else
20793         # Do we have a bin/javac?
20794         if test ! -x "$BOOT_JDK/bin/javac"; then
20795           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20796 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20797           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20798 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20799           BOOT_JDK_FOUND=no
20800         else
20801           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20802           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20803             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20804 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20805             BOOT_JDK_FOUND=no
20806           else
20807             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20808             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20809 
20810             # Extra M4 quote needed to protect [] in grep expression.
20811             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
20812             if test "x$FOUND_CORRECT_VERSION" = x; then
20813               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20814 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20815               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20816 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20817               BOOT_JDK_FOUND=no
20818             else
20819               # We're done! :-)
20820               BOOT_JDK_FOUND=yes
20821 
20822   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20823 
20824   # Input might be given as Windows format, start by converting to
20825   # unix format.
20826   path="$BOOT_JDK"
20827   new_path=`$CYGPATH -u "$path"`
20828 
20829   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20830   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20831   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20832   # "foo.exe" is OK but "foo" is an error.
20833   #
20834   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20835   # It is also a way to make sure we got the proper file name for the real test later on.
20836   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20837   if test "x$test_shortpath" = x; then
20838     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20839 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20840     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20841   fi
20842 
20843   # Call helper function which possibly converts this using DOS-style short mode.
20844   # If so, the updated path is stored in $new_path.
20845 
20846   input_path="$new_path"
20847   # Check if we need to convert this using DOS-style short mode. If the path
20848   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20849   # take no chances and rewrite it.
20850   # Note: m4 eats our [], so we need to use [ and ] instead.
20851   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20852   if test "x$has_forbidden_chars" != x; then
20853     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20854     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20855     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20856     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20857       # Going to short mode and back again did indeed matter. Since short mode is
20858       # case insensitive, let's make it lowercase to improve readability.
20859       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20860       # Now convert it back to Unix-stile (cygpath)
20861       input_path=`$CYGPATH -u "$shortmode_path"`
20862       new_path="$input_path"
20863     fi
20864   fi
20865 
20866   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20867   if test "x$test_cygdrive_prefix" = x; then
20868     # As a simple fix, exclude /usr/bin since it's not a real path.
20869     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20870       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20871       # a path prefixed by /cygdrive for fixpath to work.
20872       new_path="$CYGWIN_ROOT_PATH$input_path"
20873     fi
20874   fi
20875 
20876 
20877   if test "x$path" != "x$new_path"; then
20878     BOOT_JDK="$new_path"
20879     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20880 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20881   fi
20882 
20883   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20884 
20885   path="$BOOT_JDK"
20886   has_colon=`$ECHO $path | $GREP ^.:`
20887   new_path="$path"
20888   if test "x$has_colon" = x; then
20889     # Not in mixed or Windows style, start by that.
20890     new_path=`cmd //c echo $path`
20891   fi
20892 
20893 
20894   input_path="$new_path"
20895   # Check if we need to convert this using DOS-style short mode. If the path
20896   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20897   # take no chances and rewrite it.
20898   # Note: m4 eats our [], so we need to use [ and ] instead.
20899   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20900   if test "x$has_forbidden_chars" != x; then
20901     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20902     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20903   fi
20904 
20905 
20906   windows_path="$new_path"
20907   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20908     unix_path=`$CYGPATH -u "$windows_path"`
20909     new_path="$unix_path"
20910   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20911     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20912     new_path="$unix_path"
20913   fi
20914 
20915   if test "x$path" != "x$new_path"; then
20916     BOOT_JDK="$new_path"
20917     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20918 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20919   fi
20920 
20921   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20922   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20923 
20924   else
20925     # We're on a posix platform. Hooray! :)
20926     path="$BOOT_JDK"
20927     has_space=`$ECHO "$path" | $GREP " "`
20928     if test "x$has_space" != x; then
20929       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20930 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20931       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20932     fi
20933 
20934     # Use eval to expand a potential ~
20935     eval path="$path"
20936     if test ! -f "$path" && test ! -d "$path"; then
20937       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20938     fi
20939 
20940     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20941   fi
20942 
20943               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20944 $as_echo_n "checking for Boot JDK... " >&6; }
20945               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20946 $as_echo "$BOOT_JDK" >&6; }
20947               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20948 $as_echo_n "checking Boot JDK version... " >&6; }
20949               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20950               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20951 $as_echo "$BOOT_JDK_VERSION" >&6; }
20952             fi # end check jdk version
20953           fi # end check rt.jar
20954         fi # end check javac
20955       fi # end check java
20956     fi # end check boot jdk found
20957   fi
20958 
20959 
20960   if test "x$BOOT_JDK_FOUND" = xno; then
20961     # Now execute the test
20962 
20963   if test -x /usr/libexec/java_home; then
20964     BOOT_JDK=`/usr/libexec/java_home -v 1.7`
20965     BOOT_JDK_FOUND=maybe
20966     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&5
20967 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&6;}
20968   fi
20969 
20970 
20971     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20972     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20973       # Do we have a bin/java?
20974       if test ! -x "$BOOT_JDK/bin/java"; then
20975         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20976 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20977         BOOT_JDK_FOUND=no
20978       else
20979         # Do we have a bin/javac?
20980         if test ! -x "$BOOT_JDK/bin/javac"; then
20981           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20982 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20983           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20984 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20985           BOOT_JDK_FOUND=no
20986         else
20987           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20988           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20989             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20990 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20991             BOOT_JDK_FOUND=no
20992           else
20993             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20994             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20995 
20996             # Extra M4 quote needed to protect [] in grep expression.
20997             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
20998             if test "x$FOUND_CORRECT_VERSION" = x; then
20999               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21000 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21001               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21002 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21003               BOOT_JDK_FOUND=no
21004             else
21005               # We're done! :-)
21006               BOOT_JDK_FOUND=yes
21007 
21008   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21009 
21010   # Input might be given as Windows format, start by converting to
21011   # unix format.
21012   path="$BOOT_JDK"
21013   new_path=`$CYGPATH -u "$path"`
21014 
21015   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21016   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21017   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21018   # "foo.exe" is OK but "foo" is an error.
21019   #
21020   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21021   # It is also a way to make sure we got the proper file name for the real test later on.
21022   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21023   if test "x$test_shortpath" = x; then
21024     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21025 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21026     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21027   fi
21028 
21029   # Call helper function which possibly converts this using DOS-style short mode.
21030   # If so, the updated path is stored in $new_path.
21031 
21032   input_path="$new_path"
21033   # Check if we need to convert this using DOS-style short mode. If the path
21034   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21035   # take no chances and rewrite it.
21036   # Note: m4 eats our [], so we need to use [ and ] instead.
21037   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21038   if test "x$has_forbidden_chars" != x; then
21039     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21040     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21041     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21042     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21043       # Going to short mode and back again did indeed matter. Since short mode is
21044       # case insensitive, let's make it lowercase to improve readability.
21045       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21046       # Now convert it back to Unix-stile (cygpath)
21047       input_path=`$CYGPATH -u "$shortmode_path"`
21048       new_path="$input_path"
21049     fi
21050   fi
21051 
21052   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21053   if test "x$test_cygdrive_prefix" = x; then
21054     # As a simple fix, exclude /usr/bin since it's not a real path.
21055     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21056       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21057       # a path prefixed by /cygdrive for fixpath to work.
21058       new_path="$CYGWIN_ROOT_PATH$input_path"
21059     fi
21060   fi
21061 
21062 
21063   if test "x$path" != "x$new_path"; then
21064     BOOT_JDK="$new_path"
21065     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21066 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21067   fi
21068 
21069   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21070 
21071   path="$BOOT_JDK"
21072   has_colon=`$ECHO $path | $GREP ^.:`
21073   new_path="$path"
21074   if test "x$has_colon" = x; then
21075     # Not in mixed or Windows style, start by that.
21076     new_path=`cmd //c echo $path`
21077   fi
21078 
21079 
21080   input_path="$new_path"
21081   # Check if we need to convert this using DOS-style short mode. If the path
21082   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21083   # take no chances and rewrite it.
21084   # Note: m4 eats our [], so we need to use [ and ] instead.
21085   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21086   if test "x$has_forbidden_chars" != x; then
21087     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21088     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21089   fi
21090 
21091 
21092   windows_path="$new_path"
21093   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21094     unix_path=`$CYGPATH -u "$windows_path"`
21095     new_path="$unix_path"
21096   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21097     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21098     new_path="$unix_path"
21099   fi
21100 
21101   if test "x$path" != "x$new_path"; then
21102     BOOT_JDK="$new_path"
21103     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21104 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21105   fi
21106 
21107   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21108   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21109 
21110   else
21111     # We're on a posix platform. Hooray! :)
21112     path="$BOOT_JDK"
21113     has_space=`$ECHO "$path" | $GREP " "`
21114     if test "x$has_space" != x; then
21115       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21116 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21117       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21118     fi
21119 
21120     # Use eval to expand a potential ~
21121     eval path="$path"
21122     if test ! -f "$path" && test ! -d "$path"; then
21123       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21124     fi
21125 
21126     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21127   fi
21128 
21129               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21130 $as_echo_n "checking for Boot JDK... " >&6; }
21131               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21132 $as_echo "$BOOT_JDK" >&6; }
21133               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21134 $as_echo_n "checking Boot JDK version... " >&6; }
21135               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21136               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21137 $as_echo "$BOOT_JDK_VERSION" >&6; }
21138             fi # end check jdk version
21139           fi # end check rt.jar
21140         fi # end check javac
21141       fi # end check java
21142     fi # end check boot jdk found
21143   fi
21144 
21145   fi
21146 
21147 
21148     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21149     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21150       # Do we have a bin/java?
21151       if test ! -x "$BOOT_JDK/bin/java"; then
21152         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21153 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21154         BOOT_JDK_FOUND=no
21155       else
21156         # Do we have a bin/javac?
21157         if test ! -x "$BOOT_JDK/bin/javac"; then
21158           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21159 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21160           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21161 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21162           BOOT_JDK_FOUND=no
21163         else
21164           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
21165           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
21166             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
21167 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
21168             BOOT_JDK_FOUND=no
21169           else
21170             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21171             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21172 
21173             # Extra M4 quote needed to protect [] in grep expression.
21174             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
21175             if test "x$FOUND_CORRECT_VERSION" = x; then
21176               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21177 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21178               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21179 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21180               BOOT_JDK_FOUND=no
21181             else
21182               # We're done! :-)
21183               BOOT_JDK_FOUND=yes
21184 
21185   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21186 
21187   # Input might be given as Windows format, start by converting to
21188   # unix format.
21189   path="$BOOT_JDK"
21190   new_path=`$CYGPATH -u "$path"`
21191 
21192   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21193   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21194   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21195   # "foo.exe" is OK but "foo" is an error.
21196   #
21197   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21198   # It is also a way to make sure we got the proper file name for the real test later on.
21199   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21200   if test "x$test_shortpath" = x; then
21201     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21202 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21203     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21204   fi
21205 
21206   # Call helper function which possibly converts this using DOS-style short mode.
21207   # If so, the updated path is stored in $new_path.
21208 
21209   input_path="$new_path"
21210   # Check if we need to convert this using DOS-style short mode. If the path
21211   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21212   # take no chances and rewrite it.
21213   # Note: m4 eats our [], so we need to use [ and ] instead.
21214   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21215   if test "x$has_forbidden_chars" != x; then
21216     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21217     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21218     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21219     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21220       # Going to short mode and back again did indeed matter. Since short mode is
21221       # case insensitive, let's make it lowercase to improve readability.
21222       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21223       # Now convert it back to Unix-stile (cygpath)
21224       input_path=`$CYGPATH -u "$shortmode_path"`
21225       new_path="$input_path"
21226     fi
21227   fi
21228 
21229   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21230   if test "x$test_cygdrive_prefix" = x; then
21231     # As a simple fix, exclude /usr/bin since it's not a real path.
21232     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21233       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21234       # a path prefixed by /cygdrive for fixpath to work.
21235       new_path="$CYGWIN_ROOT_PATH$input_path"
21236     fi
21237   fi
21238 
21239 
21240   if test "x$path" != "x$new_path"; then
21241     BOOT_JDK="$new_path"
21242     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21243 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21244   fi
21245 
21246   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21247 
21248   path="$BOOT_JDK"
21249   has_colon=`$ECHO $path | $GREP ^.:`
21250   new_path="$path"
21251   if test "x$has_colon" = x; then
21252     # Not in mixed or Windows style, start by that.
21253     new_path=`cmd //c echo $path`
21254   fi
21255 
21256 
21257   input_path="$new_path"
21258   # Check if we need to convert this using DOS-style short mode. If the path
21259   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21260   # take no chances and rewrite it.
21261   # Note: m4 eats our [], so we need to use [ and ] instead.
21262   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21263   if test "x$has_forbidden_chars" != x; then
21264     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21265     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21266   fi
21267 
21268 
21269   windows_path="$new_path"
21270   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21271     unix_path=`$CYGPATH -u "$windows_path"`
21272     new_path="$unix_path"
21273   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21274     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21275     new_path="$unix_path"
21276   fi
21277 
21278   if test "x$path" != "x$new_path"; then
21279     BOOT_JDK="$new_path"
21280     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21281 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21282   fi
21283 
21284   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21285   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21286 
21287   else
21288     # We're on a posix platform. Hooray! :)
21289     path="$BOOT_JDK"
21290     has_space=`$ECHO "$path" | $GREP " "`
21291     if test "x$has_space" != x; then
21292       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21293 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21294       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21295     fi
21296 
21297     # Use eval to expand a potential ~
21298     eval path="$path"
21299     if test ! -f "$path" && test ! -d "$path"; then
21300       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21301     fi
21302 
21303     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21304   fi
21305 
21306               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21307 $as_echo_n "checking for Boot JDK... " >&6; }
21308               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21309 $as_echo "$BOOT_JDK" >&6; }
21310               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21311 $as_echo_n "checking Boot JDK version... " >&6; }
21312               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21313               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21314 $as_echo "$BOOT_JDK_VERSION" >&6; }
21315             fi # end check jdk version
21316           fi # end check rt.jar
21317         fi # end check javac
21318       fi # end check java
21319     fi # end check boot jdk found
21320   fi
21321 
21322 
21323   # Test: Is $JAVA_HOME set?
21324 
21325   if test "x$BOOT_JDK_FOUND" = xno; then
21326     # Now execute the test
21327 
21328   if test "x$JAVA_HOME" != x; then
21329     JAVA_HOME_PROCESSED="$JAVA_HOME"
21330 
21331   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21332 
21333   # Input might be given as Windows format, start by converting to
21334   # unix format.
21335   path="$JAVA_HOME_PROCESSED"
21336   new_path=`$CYGPATH -u "$path"`
21337 
21338   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21339   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21340   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21341   # "foo.exe" is OK but "foo" is an error.
21342   #
21343   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21344   # It is also a way to make sure we got the proper file name for the real test later on.
21345   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21346   if test "x$test_shortpath" = x; then
21347     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
21348 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
21349     as_fn_error $? "Cannot locate the the path of JAVA_HOME_PROCESSED" "$LINENO" 5
21350   fi
21351 
21352   # Call helper function which possibly converts this using DOS-style short mode.
21353   # If so, the updated path is stored in $new_path.
21354 
21355   input_path="$new_path"
21356   # Check if we need to convert this using DOS-style short mode. If the path
21357   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21358   # take no chances and rewrite it.
21359   # Note: m4 eats our [], so we need to use [ and ] instead.
21360   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21361   if test "x$has_forbidden_chars" != x; then
21362     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21363     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21364     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21365     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21366       # Going to short mode and back again did indeed matter. Since short mode is
21367       # case insensitive, let's make it lowercase to improve readability.
21368       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21369       # Now convert it back to Unix-stile (cygpath)
21370       input_path=`$CYGPATH -u "$shortmode_path"`
21371       new_path="$input_path"
21372     fi
21373   fi
21374 
21375   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21376   if test "x$test_cygdrive_prefix" = x; then
21377     # As a simple fix, exclude /usr/bin since it's not a real path.
21378     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21379       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21380       # a path prefixed by /cygdrive for fixpath to work.
21381       new_path="$CYGWIN_ROOT_PATH$input_path"
21382     fi
21383   fi
21384 
21385 
21386   if test "x$path" != "x$new_path"; then
21387     JAVA_HOME_PROCESSED="$new_path"
21388     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
21389 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
21390   fi
21391 
21392   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21393 
21394   path="$JAVA_HOME_PROCESSED"
21395   has_colon=`$ECHO $path | $GREP ^.:`
21396   new_path="$path"
21397   if test "x$has_colon" = x; then
21398     # Not in mixed or Windows style, start by that.
21399     new_path=`cmd //c echo $path`
21400   fi
21401 
21402 
21403   input_path="$new_path"
21404   # Check if we need to convert this using DOS-style short mode. If the path
21405   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21406   # take no chances and rewrite it.
21407   # Note: m4 eats our [], so we need to use [ and ] instead.
21408   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21409   if test "x$has_forbidden_chars" != x; then
21410     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21411     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21412   fi
21413 
21414 
21415   windows_path="$new_path"
21416   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21417     unix_path=`$CYGPATH -u "$windows_path"`
21418     new_path="$unix_path"
21419   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21420     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21421     new_path="$unix_path"
21422   fi
21423 
21424   if test "x$path" != "x$new_path"; then
21425     JAVA_HOME_PROCESSED="$new_path"
21426     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
21427 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
21428   fi
21429 
21430   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21431   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21432 
21433   else
21434     # We're on a posix platform. Hooray! :)
21435     path="$JAVA_HOME_PROCESSED"
21436     has_space=`$ECHO "$path" | $GREP " "`
21437     if test "x$has_space" != x; then
21438       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
21439 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
21440       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21441     fi
21442 
21443     # Use eval to expand a potential ~
21444     eval path="$path"
21445     if test ! -f "$path" && test ! -d "$path"; then
21446       as_fn_error $? "The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is not found." "$LINENO" 5
21447     fi
21448 
21449     JAVA_HOME_PROCESSED="`cd "$path"; $THEPWDCMD -L`"
21450   fi
21451 
21452     if test ! -d "$JAVA_HOME_PROCESSED"; then
21453       { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
21454 $as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
21455     else
21456       # Aha, the user has set a JAVA_HOME
21457       # let us use that as the Boot JDK.
21458       BOOT_JDK="$JAVA_HOME_PROCESSED"
21459       BOOT_JDK_FOUND=maybe
21460       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using JAVA_HOME" >&5
21461 $as_echo "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
21462     fi
21463   fi
21464 
21465 
21466     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21467     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21468       # Do we have a bin/java?
21469       if test ! -x "$BOOT_JDK/bin/java"; then
21470         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21471 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21472         BOOT_JDK_FOUND=no
21473       else
21474         # Do we have a bin/javac?
21475         if test ! -x "$BOOT_JDK/bin/javac"; then
21476           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21477 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21478           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21479 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21480           BOOT_JDK_FOUND=no
21481         else
21482           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
21483           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
21484             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
21485 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
21486             BOOT_JDK_FOUND=no
21487           else
21488             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21489             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21490 
21491             # Extra M4 quote needed to protect [] in grep expression.
21492             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
21493             if test "x$FOUND_CORRECT_VERSION" = x; then
21494               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21495 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21496               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21497 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21498               BOOT_JDK_FOUND=no
21499             else
21500               # We're done! :-)
21501               BOOT_JDK_FOUND=yes
21502 
21503   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21504 
21505   # Input might be given as Windows format, start by converting to
21506   # unix format.
21507   path="$BOOT_JDK"
21508   new_path=`$CYGPATH -u "$path"`
21509 
21510   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21511   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21512   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21513   # "foo.exe" is OK but "foo" is an error.
21514   #
21515   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21516   # It is also a way to make sure we got the proper file name for the real test later on.
21517   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21518   if test "x$test_shortpath" = x; then
21519     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21520 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21521     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21522   fi
21523 
21524   # Call helper function which possibly converts this using DOS-style short mode.
21525   # If so, the updated path is stored in $new_path.
21526 
21527   input_path="$new_path"
21528   # Check if we need to convert this using DOS-style short mode. If the path
21529   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21530   # take no chances and rewrite it.
21531   # Note: m4 eats our [], so we need to use [ and ] instead.
21532   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21533   if test "x$has_forbidden_chars" != x; then
21534     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21535     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21536     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21537     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21538       # Going to short mode and back again did indeed matter. Since short mode is
21539       # case insensitive, let's make it lowercase to improve readability.
21540       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21541       # Now convert it back to Unix-stile (cygpath)
21542       input_path=`$CYGPATH -u "$shortmode_path"`
21543       new_path="$input_path"
21544     fi
21545   fi
21546 
21547   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21548   if test "x$test_cygdrive_prefix" = x; then
21549     # As a simple fix, exclude /usr/bin since it's not a real path.
21550     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21551       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21552       # a path prefixed by /cygdrive for fixpath to work.
21553       new_path="$CYGWIN_ROOT_PATH$input_path"
21554     fi
21555   fi
21556 
21557 
21558   if test "x$path" != "x$new_path"; then
21559     BOOT_JDK="$new_path"
21560     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21561 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21562   fi
21563 
21564   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21565 
21566   path="$BOOT_JDK"
21567   has_colon=`$ECHO $path | $GREP ^.:`
21568   new_path="$path"
21569   if test "x$has_colon" = x; then
21570     # Not in mixed or Windows style, start by that.
21571     new_path=`cmd //c echo $path`
21572   fi
21573 
21574 
21575   input_path="$new_path"
21576   # Check if we need to convert this using DOS-style short mode. If the path
21577   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21578   # take no chances and rewrite it.
21579   # Note: m4 eats our [], so we need to use [ and ] instead.
21580   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21581   if test "x$has_forbidden_chars" != x; then
21582     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21583     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21584   fi
21585 
21586 
21587   windows_path="$new_path"
21588   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21589     unix_path=`$CYGPATH -u "$windows_path"`
21590     new_path="$unix_path"
21591   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21592     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21593     new_path="$unix_path"
21594   fi
21595 
21596   if test "x$path" != "x$new_path"; then
21597     BOOT_JDK="$new_path"
21598     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21599 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21600   fi
21601 
21602   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21603   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21604 
21605   else
21606     # We're on a posix platform. Hooray! :)
21607     path="$BOOT_JDK"
21608     has_space=`$ECHO "$path" | $GREP " "`
21609     if test "x$has_space" != x; then
21610       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21611 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21612       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21613     fi
21614 
21615     # Use eval to expand a potential ~
21616     eval path="$path"
21617     if test ! -f "$path" && test ! -d "$path"; then
21618       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21619     fi
21620 
21621     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21622   fi
21623 
21624               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21625 $as_echo_n "checking for Boot JDK... " >&6; }
21626               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21627 $as_echo "$BOOT_JDK" >&6; }
21628               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21629 $as_echo_n "checking Boot JDK version... " >&6; }
21630               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21631               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21632 $as_echo "$BOOT_JDK_VERSION" >&6; }
21633             fi # end check jdk version
21634           fi # end check rt.jar
21635         fi # end check javac
21636       fi # end check java
21637     fi # end check boot jdk found
21638   fi
21639 
21640 
21641   # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
21642 
21643   if test "x$BOOT_JDK_FOUND" = xno; then
21644     # Now execute the test
21645 
21646   # Extract the first word of "javac", so it can be a program name with args.
21647 set dummy javac; ac_word=$2
21648 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21649 $as_echo_n "checking for $ac_word... " >&6; }
21650 if ${ac_cv_path_JAVAC_CHECK+:} false; then :
21651   $as_echo_n "(cached) " >&6
21652 else
21653   case $JAVAC_CHECK in
21654   [\\/]* | ?:[\\/]*)
21655   ac_cv_path_JAVAC_CHECK="$JAVAC_CHECK" # Let the user override the test with a path.
21656   ;;
21657   *)
21658   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21659 for as_dir in $PATH
21660 do
21661   IFS=$as_save_IFS
21662   test -z "$as_dir" && as_dir=.
21663     for ac_exec_ext in '' $ac_executable_extensions; do
21664   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21665     ac_cv_path_JAVAC_CHECK="$as_dir/$ac_word$ac_exec_ext"
21666     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21667     break 2
21668   fi
21669 done
21670   done
21671 IFS=$as_save_IFS
21672 
21673   ;;
21674 esac
21675 fi
21676 JAVAC_CHECK=$ac_cv_path_JAVAC_CHECK
21677 if test -n "$JAVAC_CHECK"; then
21678   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5
21679 $as_echo "$JAVAC_CHECK" >&6; }
21680 else
21681   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21682 $as_echo "no" >&6; }
21683 fi
21684 
21685 
21686   # Extract the first word of "java", so it can be a program name with args.
21687 set dummy java; ac_word=$2
21688 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21689 $as_echo_n "checking for $ac_word... " >&6; }
21690 if ${ac_cv_path_JAVA_CHECK+:} false; then :
21691   $as_echo_n "(cached) " >&6
21692 else
21693   case $JAVA_CHECK in
21694   [\\/]* | ?:[\\/]*)
21695   ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path.
21696   ;;
21697   *)
21698   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21699 for as_dir in $PATH
21700 do
21701   IFS=$as_save_IFS
21702   test -z "$as_dir" && as_dir=.
21703     for ac_exec_ext in '' $ac_executable_extensions; do
21704   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21705     ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext"
21706     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21707     break 2
21708   fi
21709 done
21710   done
21711 IFS=$as_save_IFS
21712 
21713   ;;
21714 esac
21715 fi
21716 JAVA_CHECK=$ac_cv_path_JAVA_CHECK
21717 if test -n "$JAVA_CHECK"; then
21718   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5
21719 $as_echo "$JAVA_CHECK" >&6; }
21720 else
21721   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21722 $as_echo "no" >&6; }
21723 fi
21724 
21725 
21726   BINARY="$JAVAC_CHECK"
21727   if test "x$JAVAC_CHECK" = x; then
21728     BINARY="$JAVA_CHECK"
21729   fi
21730   if test "x$BINARY" != x; then
21731     # So there is a java(c) binary, it might be part of a JDK.
21732     # Lets find the JDK/JRE directory by following symbolic links.
21733     # Linux/GNU systems often have links from /usr/bin/java to
21734     # /etc/alternatives/java to the real JDK binary.
21735 
21736   if test "x$OPENJDK_BUILD_OS" != xwindows; then
21737     # Follow a chain of symbolic links. Use readlink
21738     # where it exists, else fall back to horribly
21739     # complicated shell code.
21740     if test "x$READLINK_TESTED" != yes; then
21741       # On MacOSX there is a readlink tool with a different
21742       # purpose than the GNU readlink tool. Check the found readlink.
21743       ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
21744       if test "x$ISGNU" = x; then
21745         # A readlink that we do not know how to use.
21746         # Are there other non-GNU readlinks out there?
21747         READLINK_TESTED=yes
21748         READLINK=
21749       fi
21750     fi
21751 
21752     if test "x$READLINK" != x; then
21753       BINARY=`$READLINK -f $BINARY`
21754     else
21755       # Save the current directory for restoring afterwards
21756       STARTDIR=$PWD
21757       COUNTER=0
21758       sym_link_dir=`$DIRNAME $BINARY`
21759       sym_link_file=`$BASENAME $BINARY`
21760       cd $sym_link_dir
21761       # Use -P flag to resolve symlinks in directories.
21762       cd `$THEPWDCMD -P`
21763       sym_link_dir=`$THEPWDCMD -P`
21764       # Resolve file symlinks
21765       while test $COUNTER -lt 20; do
21766         ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
21767         if test "x$ISLINK" == x; then
21768           # This is not a symbolic link! We are done!
21769           break
21770         fi
21771         # Again resolve directory symlinks since the target of the just found
21772         # link could be in a different directory
21773         cd `$DIRNAME $ISLINK`
21774         sym_link_dir=`$THEPWDCMD -P`
21775         sym_link_file=`$BASENAME $ISLINK`
21776         let COUNTER=COUNTER+1
21777       done
21778       cd $STARTDIR
21779       BINARY=$sym_link_dir/$sym_link_file
21780     fi
21781   fi
21782 
21783     BOOT_JDK=`dirname "$BINARY"`
21784     BOOT_JDK=`cd "$BOOT_JDK/.."; pwd`
21785     if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then
21786       # Looks like we found ourselves an JDK
21787       BOOT_JDK_FOUND=maybe
21788       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using java(c) in PATH" >&5
21789 $as_echo "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
21790     fi
21791   fi
21792 
21793 
21794     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21795     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21796       # Do we have a bin/java?
21797       if test ! -x "$BOOT_JDK/bin/java"; then
21798         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21799 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21800         BOOT_JDK_FOUND=no
21801       else
21802         # Do we have a bin/javac?
21803         if test ! -x "$BOOT_JDK/bin/javac"; then
21804           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21805 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21806           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21807 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21808           BOOT_JDK_FOUND=no
21809         else
21810           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
21811           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
21812             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
21813 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
21814             BOOT_JDK_FOUND=no
21815           else
21816             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21817             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21818 
21819             # Extra M4 quote needed to protect [] in grep expression.
21820             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
21821             if test "x$FOUND_CORRECT_VERSION" = x; then
21822               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21823 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21824               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21825 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21826               BOOT_JDK_FOUND=no
21827             else
21828               # We're done! :-)
21829               BOOT_JDK_FOUND=yes
21830 
21831   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21832 
21833   # Input might be given as Windows format, start by converting to
21834   # unix format.
21835   path="$BOOT_JDK"
21836   new_path=`$CYGPATH -u "$path"`
21837 
21838   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21839   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21840   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21841   # "foo.exe" is OK but "foo" is an error.
21842   #
21843   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21844   # It is also a way to make sure we got the proper file name for the real test later on.
21845   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21846   if test "x$test_shortpath" = x; then
21847     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21848 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21849     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21850   fi
21851 
21852   # Call helper function which possibly converts this using DOS-style short mode.
21853   # If so, the updated path is stored in $new_path.
21854 
21855   input_path="$new_path"
21856   # Check if we need to convert this using DOS-style short mode. If the path
21857   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21858   # take no chances and rewrite it.
21859   # Note: m4 eats our [], so we need to use [ and ] instead.
21860   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21861   if test "x$has_forbidden_chars" != x; then
21862     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21863     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21864     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21865     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21866       # Going to short mode and back again did indeed matter. Since short mode is
21867       # case insensitive, let's make it lowercase to improve readability.
21868       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21869       # Now convert it back to Unix-stile (cygpath)
21870       input_path=`$CYGPATH -u "$shortmode_path"`
21871       new_path="$input_path"
21872     fi
21873   fi
21874 
21875   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21876   if test "x$test_cygdrive_prefix" = x; then
21877     # As a simple fix, exclude /usr/bin since it's not a real path.
21878     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21879       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21880       # a path prefixed by /cygdrive for fixpath to work.
21881       new_path="$CYGWIN_ROOT_PATH$input_path"
21882     fi
21883   fi
21884 
21885 
21886   if test "x$path" != "x$new_path"; then
21887     BOOT_JDK="$new_path"
21888     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21889 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21890   fi
21891 
21892   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21893 
21894   path="$BOOT_JDK"
21895   has_colon=`$ECHO $path | $GREP ^.:`
21896   new_path="$path"
21897   if test "x$has_colon" = x; then
21898     # Not in mixed or Windows style, start by that.
21899     new_path=`cmd //c echo $path`
21900   fi
21901 
21902 
21903   input_path="$new_path"
21904   # Check if we need to convert this using DOS-style short mode. If the path
21905   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21906   # take no chances and rewrite it.
21907   # Note: m4 eats our [], so we need to use [ and ] instead.
21908   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21909   if test "x$has_forbidden_chars" != x; then
21910     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21911     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21912   fi
21913 
21914 
21915   windows_path="$new_path"
21916   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21917     unix_path=`$CYGPATH -u "$windows_path"`
21918     new_path="$unix_path"
21919   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21920     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21921     new_path="$unix_path"
21922   fi
21923 
21924   if test "x$path" != "x$new_path"; then
21925     BOOT_JDK="$new_path"
21926     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21927 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21928   fi
21929 
21930   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21931   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21932 
21933   else
21934     # We're on a posix platform. Hooray! :)
21935     path="$BOOT_JDK"
21936     has_space=`$ECHO "$path" | $GREP " "`
21937     if test "x$has_space" != x; then
21938       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21939 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21940       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21941     fi
21942 
21943     # Use eval to expand a potential ~
21944     eval path="$path"
21945     if test ! -f "$path" && test ! -d "$path"; then
21946       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21947     fi
21948 
21949     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21950   fi
21951 
21952               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21953 $as_echo_n "checking for Boot JDK... " >&6; }
21954               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21955 $as_echo "$BOOT_JDK" >&6; }
21956               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21957 $as_echo_n "checking Boot JDK version... " >&6; }
21958               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21959               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21960 $as_echo "$BOOT_JDK_VERSION" >&6; }
21961             fi # end check jdk version
21962           fi # end check rt.jar
21963         fi # end check javac
21964       fi # end check java
21965     fi # end check boot jdk found
21966   fi
21967 
21968 
21969   # Test: Is there a JDK installed in default, well-known locations?
21970 
21971   if test "x$BOOT_JDK_FOUND" = xno; then
21972     # Now execute the test
21973 
21974   if test "x$OPENJDK_TARGET_OS" = xwindows; then
21975 
21976   if test "x$BOOT_JDK_FOUND" = xno; then
21977     # Now execute the test
21978 
21979   if test "x$ProgramW6432" != x; then
21980     VIRTUAL_DIR="$ProgramW6432/Java"
21981 
21982   windows_path="$VIRTUAL_DIR"
21983   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21984     unix_path=`$CYGPATH -u "$windows_path"`
21985     VIRTUAL_DIR="$unix_path"
21986   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21987     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21988     VIRTUAL_DIR="$unix_path"
21989   fi
21990 
21991 
21992   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
21993   BOOT_JDK_SUFFIX=""
21994   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
21995   if test "x$ALL_JDKS_FOUND" != x; then
21996     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
21997 
21998   if test "x$BOOT_JDK_FOUND" = xno; then
21999     # Now execute the test
22000 
22001         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22002         if test -d "$BOOT_JDK"; then
22003           BOOT_JDK_FOUND=maybe
22004           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22005 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22006         fi
22007 
22008 
22009     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22010     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22011       # Do we have a bin/java?
22012       if test ! -x "$BOOT_JDK/bin/java"; then
22013         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22014 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22015         BOOT_JDK_FOUND=no
22016       else
22017         # Do we have a bin/javac?
22018         if test ! -x "$BOOT_JDK/bin/javac"; then
22019           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22020 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22021           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22022 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22023           BOOT_JDK_FOUND=no
22024         else
22025           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22026           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22027             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22028 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22029             BOOT_JDK_FOUND=no
22030           else
22031             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22032             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22033 
22034             # Extra M4 quote needed to protect [] in grep expression.
22035             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22036             if test "x$FOUND_CORRECT_VERSION" = x; then
22037               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22038 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22039               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22040 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22041               BOOT_JDK_FOUND=no
22042             else
22043               # We're done! :-)
22044               BOOT_JDK_FOUND=yes
22045 
22046   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22047 
22048   # Input might be given as Windows format, start by converting to
22049   # unix format.
22050   path="$BOOT_JDK"
22051   new_path=`$CYGPATH -u "$path"`
22052 
22053   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22054   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22055   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22056   # "foo.exe" is OK but "foo" is an error.
22057   #
22058   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22059   # It is also a way to make sure we got the proper file name for the real test later on.
22060   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22061   if test "x$test_shortpath" = x; then
22062     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22063 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22064     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22065   fi
22066 
22067   # Call helper function which possibly converts this using DOS-style short mode.
22068   # If so, the updated path is stored in $new_path.
22069 
22070   input_path="$new_path"
22071   # Check if we need to convert this using DOS-style short mode. If the path
22072   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22073   # take no chances and rewrite it.
22074   # Note: m4 eats our [], so we need to use [ and ] instead.
22075   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22076   if test "x$has_forbidden_chars" != x; then
22077     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22078     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22079     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22080     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22081       # Going to short mode and back again did indeed matter. Since short mode is
22082       # case insensitive, let's make it lowercase to improve readability.
22083       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22084       # Now convert it back to Unix-stile (cygpath)
22085       input_path=`$CYGPATH -u "$shortmode_path"`
22086       new_path="$input_path"
22087     fi
22088   fi
22089 
22090   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22091   if test "x$test_cygdrive_prefix" = x; then
22092     # As a simple fix, exclude /usr/bin since it's not a real path.
22093     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22094       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22095       # a path prefixed by /cygdrive for fixpath to work.
22096       new_path="$CYGWIN_ROOT_PATH$input_path"
22097     fi
22098   fi
22099 
22100 
22101   if test "x$path" != "x$new_path"; then
22102     BOOT_JDK="$new_path"
22103     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22104 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22105   fi
22106 
22107   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22108 
22109   path="$BOOT_JDK"
22110   has_colon=`$ECHO $path | $GREP ^.:`
22111   new_path="$path"
22112   if test "x$has_colon" = x; then
22113     # Not in mixed or Windows style, start by that.
22114     new_path=`cmd //c echo $path`
22115   fi
22116 
22117 
22118   input_path="$new_path"
22119   # Check if we need to convert this using DOS-style short mode. If the path
22120   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22121   # take no chances and rewrite it.
22122   # Note: m4 eats our [], so we need to use [ and ] instead.
22123   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22124   if test "x$has_forbidden_chars" != x; then
22125     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22126     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22127   fi
22128 
22129 
22130   windows_path="$new_path"
22131   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22132     unix_path=`$CYGPATH -u "$windows_path"`
22133     new_path="$unix_path"
22134   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22135     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22136     new_path="$unix_path"
22137   fi
22138 
22139   if test "x$path" != "x$new_path"; then
22140     BOOT_JDK="$new_path"
22141     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22142 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22143   fi
22144 
22145   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22146   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22147 
22148   else
22149     # We're on a posix platform. Hooray! :)
22150     path="$BOOT_JDK"
22151     has_space=`$ECHO "$path" | $GREP " "`
22152     if test "x$has_space" != x; then
22153       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22154 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22155       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22156     fi
22157 
22158     # Use eval to expand a potential ~
22159     eval path="$path"
22160     if test ! -f "$path" && test ! -d "$path"; then
22161       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22162     fi
22163 
22164     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22165   fi
22166 
22167               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22168 $as_echo_n "checking for Boot JDK... " >&6; }
22169               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22170 $as_echo "$BOOT_JDK" >&6; }
22171               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22172 $as_echo_n "checking Boot JDK version... " >&6; }
22173               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22174               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22175 $as_echo "$BOOT_JDK_VERSION" >&6; }
22176             fi # end check jdk version
22177           fi # end check rt.jar
22178         fi # end check javac
22179       fi # end check java
22180     fi # end check boot jdk found
22181   fi
22182 
22183     done
22184   fi
22185 
22186   fi
22187 
22188 
22189     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22190     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22191       # Do we have a bin/java?
22192       if test ! -x "$BOOT_JDK/bin/java"; then
22193         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22194 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22195         BOOT_JDK_FOUND=no
22196       else
22197         # Do we have a bin/javac?
22198         if test ! -x "$BOOT_JDK/bin/javac"; then
22199           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22200 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22201           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22202 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22203           BOOT_JDK_FOUND=no
22204         else
22205           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22206           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22207             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22208 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22209             BOOT_JDK_FOUND=no
22210           else
22211             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22212             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22213 
22214             # Extra M4 quote needed to protect [] in grep expression.
22215             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22216             if test "x$FOUND_CORRECT_VERSION" = x; then
22217               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22218 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22219               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22220 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22221               BOOT_JDK_FOUND=no
22222             else
22223               # We're done! :-)
22224               BOOT_JDK_FOUND=yes
22225 
22226   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22227 
22228   # Input might be given as Windows format, start by converting to
22229   # unix format.
22230   path="$BOOT_JDK"
22231   new_path=`$CYGPATH -u "$path"`
22232 
22233   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22234   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22235   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22236   # "foo.exe" is OK but "foo" is an error.
22237   #
22238   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22239   # It is also a way to make sure we got the proper file name for the real test later on.
22240   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22241   if test "x$test_shortpath" = x; then
22242     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22243 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22244     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22245   fi
22246 
22247   # Call helper function which possibly converts this using DOS-style short mode.
22248   # If so, the updated path is stored in $new_path.
22249 
22250   input_path="$new_path"
22251   # Check if we need to convert this using DOS-style short mode. If the path
22252   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22253   # take no chances and rewrite it.
22254   # Note: m4 eats our [], so we need to use [ and ] instead.
22255   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22256   if test "x$has_forbidden_chars" != x; then
22257     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22258     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22259     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22260     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22261       # Going to short mode and back again did indeed matter. Since short mode is
22262       # case insensitive, let's make it lowercase to improve readability.
22263       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22264       # Now convert it back to Unix-stile (cygpath)
22265       input_path=`$CYGPATH -u "$shortmode_path"`
22266       new_path="$input_path"
22267     fi
22268   fi
22269 
22270   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22271   if test "x$test_cygdrive_prefix" = x; then
22272     # As a simple fix, exclude /usr/bin since it's not a real path.
22273     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22274       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22275       # a path prefixed by /cygdrive for fixpath to work.
22276       new_path="$CYGWIN_ROOT_PATH$input_path"
22277     fi
22278   fi
22279 
22280 
22281   if test "x$path" != "x$new_path"; then
22282     BOOT_JDK="$new_path"
22283     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22284 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22285   fi
22286 
22287   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22288 
22289   path="$BOOT_JDK"
22290   has_colon=`$ECHO $path | $GREP ^.:`
22291   new_path="$path"
22292   if test "x$has_colon" = x; then
22293     # Not in mixed or Windows style, start by that.
22294     new_path=`cmd //c echo $path`
22295   fi
22296 
22297 
22298   input_path="$new_path"
22299   # Check if we need to convert this using DOS-style short mode. If the path
22300   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22301   # take no chances and rewrite it.
22302   # Note: m4 eats our [], so we need to use [ and ] instead.
22303   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22304   if test "x$has_forbidden_chars" != x; then
22305     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22306     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22307   fi
22308 
22309 
22310   windows_path="$new_path"
22311   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22312     unix_path=`$CYGPATH -u "$windows_path"`
22313     new_path="$unix_path"
22314   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22315     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22316     new_path="$unix_path"
22317   fi
22318 
22319   if test "x$path" != "x$new_path"; then
22320     BOOT_JDK="$new_path"
22321     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22322 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22323   fi
22324 
22325   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22326   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22327 
22328   else
22329     # We're on a posix platform. Hooray! :)
22330     path="$BOOT_JDK"
22331     has_space=`$ECHO "$path" | $GREP " "`
22332     if test "x$has_space" != x; then
22333       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22334 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22335       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22336     fi
22337 
22338     # Use eval to expand a potential ~
22339     eval path="$path"
22340     if test ! -f "$path" && test ! -d "$path"; then
22341       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22342     fi
22343 
22344     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22345   fi
22346 
22347               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22348 $as_echo_n "checking for Boot JDK... " >&6; }
22349               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22350 $as_echo "$BOOT_JDK" >&6; }
22351               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22352 $as_echo_n "checking Boot JDK version... " >&6; }
22353               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22354               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22355 $as_echo "$BOOT_JDK_VERSION" >&6; }
22356             fi # end check jdk version
22357           fi # end check rt.jar
22358         fi # end check javac
22359       fi # end check java
22360     fi # end check boot jdk found
22361   fi
22362 
22363 
22364   if test "x$BOOT_JDK_FOUND" = xno; then
22365     # Now execute the test
22366 
22367   if test "x$PROGRAMW6432" != x; then
22368     VIRTUAL_DIR="$PROGRAMW6432/Java"
22369 
22370   windows_path="$VIRTUAL_DIR"
22371   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22372     unix_path=`$CYGPATH -u "$windows_path"`
22373     VIRTUAL_DIR="$unix_path"
22374   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22375     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22376     VIRTUAL_DIR="$unix_path"
22377   fi
22378 
22379 
22380   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22381   BOOT_JDK_SUFFIX=""
22382   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22383   if test "x$ALL_JDKS_FOUND" != x; then
22384     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22385 
22386   if test "x$BOOT_JDK_FOUND" = xno; then
22387     # Now execute the test
22388 
22389         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22390         if test -d "$BOOT_JDK"; then
22391           BOOT_JDK_FOUND=maybe
22392           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22393 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22394         fi
22395 
22396 
22397     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22398     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22399       # Do we have a bin/java?
22400       if test ! -x "$BOOT_JDK/bin/java"; then
22401         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22402 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22403         BOOT_JDK_FOUND=no
22404       else
22405         # Do we have a bin/javac?
22406         if test ! -x "$BOOT_JDK/bin/javac"; then
22407           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22408 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22409           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22410 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22411           BOOT_JDK_FOUND=no
22412         else
22413           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22414           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22415             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22416 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22417             BOOT_JDK_FOUND=no
22418           else
22419             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22420             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22421 
22422             # Extra M4 quote needed to protect [] in grep expression.
22423             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22424             if test "x$FOUND_CORRECT_VERSION" = x; then
22425               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22426 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22427               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22428 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22429               BOOT_JDK_FOUND=no
22430             else
22431               # We're done! :-)
22432               BOOT_JDK_FOUND=yes
22433 
22434   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22435 
22436   # Input might be given as Windows format, start by converting to
22437   # unix format.
22438   path="$BOOT_JDK"
22439   new_path=`$CYGPATH -u "$path"`
22440 
22441   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22442   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22443   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22444   # "foo.exe" is OK but "foo" is an error.
22445   #
22446   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22447   # It is also a way to make sure we got the proper file name for the real test later on.
22448   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22449   if test "x$test_shortpath" = x; then
22450     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22451 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22452     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22453   fi
22454 
22455   # Call helper function which possibly converts this using DOS-style short mode.
22456   # If so, the updated path is stored in $new_path.
22457 
22458   input_path="$new_path"
22459   # Check if we need to convert this using DOS-style short mode. If the path
22460   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22461   # take no chances and rewrite it.
22462   # Note: m4 eats our [], so we need to use [ and ] instead.
22463   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22464   if test "x$has_forbidden_chars" != x; then
22465     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22466     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22467     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22468     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22469       # Going to short mode and back again did indeed matter. Since short mode is
22470       # case insensitive, let's make it lowercase to improve readability.
22471       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22472       # Now convert it back to Unix-stile (cygpath)
22473       input_path=`$CYGPATH -u "$shortmode_path"`
22474       new_path="$input_path"
22475     fi
22476   fi
22477 
22478   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22479   if test "x$test_cygdrive_prefix" = x; then
22480     # As a simple fix, exclude /usr/bin since it's not a real path.
22481     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22482       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22483       # a path prefixed by /cygdrive for fixpath to work.
22484       new_path="$CYGWIN_ROOT_PATH$input_path"
22485     fi
22486   fi
22487 
22488 
22489   if test "x$path" != "x$new_path"; then
22490     BOOT_JDK="$new_path"
22491     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22492 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22493   fi
22494 
22495   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22496 
22497   path="$BOOT_JDK"
22498   has_colon=`$ECHO $path | $GREP ^.:`
22499   new_path="$path"
22500   if test "x$has_colon" = x; then
22501     # Not in mixed or Windows style, start by that.
22502     new_path=`cmd //c echo $path`
22503   fi
22504 
22505 
22506   input_path="$new_path"
22507   # Check if we need to convert this using DOS-style short mode. If the path
22508   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22509   # take no chances and rewrite it.
22510   # Note: m4 eats our [], so we need to use [ and ] instead.
22511   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22512   if test "x$has_forbidden_chars" != x; then
22513     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22514     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22515   fi
22516 
22517 
22518   windows_path="$new_path"
22519   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22520     unix_path=`$CYGPATH -u "$windows_path"`
22521     new_path="$unix_path"
22522   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22523     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22524     new_path="$unix_path"
22525   fi
22526 
22527   if test "x$path" != "x$new_path"; then
22528     BOOT_JDK="$new_path"
22529     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22530 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22531   fi
22532 
22533   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22534   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22535 
22536   else
22537     # We're on a posix platform. Hooray! :)
22538     path="$BOOT_JDK"
22539     has_space=`$ECHO "$path" | $GREP " "`
22540     if test "x$has_space" != x; then
22541       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22542 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22543       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22544     fi
22545 
22546     # Use eval to expand a potential ~
22547     eval path="$path"
22548     if test ! -f "$path" && test ! -d "$path"; then
22549       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22550     fi
22551 
22552     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22553   fi
22554 
22555               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22556 $as_echo_n "checking for Boot JDK... " >&6; }
22557               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22558 $as_echo "$BOOT_JDK" >&6; }
22559               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22560 $as_echo_n "checking Boot JDK version... " >&6; }
22561               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22562               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22563 $as_echo "$BOOT_JDK_VERSION" >&6; }
22564             fi # end check jdk version
22565           fi # end check rt.jar
22566         fi # end check javac
22567       fi # end check java
22568     fi # end check boot jdk found
22569   fi
22570 
22571     done
22572   fi
22573 
22574   fi
22575 
22576 
22577     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22578     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22579       # Do we have a bin/java?
22580       if test ! -x "$BOOT_JDK/bin/java"; then
22581         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22582 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22583         BOOT_JDK_FOUND=no
22584       else
22585         # Do we have a bin/javac?
22586         if test ! -x "$BOOT_JDK/bin/javac"; then
22587           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22588 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22589           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22590 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22591           BOOT_JDK_FOUND=no
22592         else
22593           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22594           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22595             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22596 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22597             BOOT_JDK_FOUND=no
22598           else
22599             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22600             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22601 
22602             # Extra M4 quote needed to protect [] in grep expression.
22603             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22604             if test "x$FOUND_CORRECT_VERSION" = x; then
22605               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22606 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22607               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22608 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22609               BOOT_JDK_FOUND=no
22610             else
22611               # We're done! :-)
22612               BOOT_JDK_FOUND=yes
22613 
22614   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22615 
22616   # Input might be given as Windows format, start by converting to
22617   # unix format.
22618   path="$BOOT_JDK"
22619   new_path=`$CYGPATH -u "$path"`
22620 
22621   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22622   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22623   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22624   # "foo.exe" is OK but "foo" is an error.
22625   #
22626   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22627   # It is also a way to make sure we got the proper file name for the real test later on.
22628   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22629   if test "x$test_shortpath" = x; then
22630     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22631 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22632     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22633   fi
22634 
22635   # Call helper function which possibly converts this using DOS-style short mode.
22636   # If so, the updated path is stored in $new_path.
22637 
22638   input_path="$new_path"
22639   # Check if we need to convert this using DOS-style short mode. If the path
22640   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22641   # take no chances and rewrite it.
22642   # Note: m4 eats our [], so we need to use [ and ] instead.
22643   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22644   if test "x$has_forbidden_chars" != x; then
22645     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22646     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22647     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22648     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22649       # Going to short mode and back again did indeed matter. Since short mode is
22650       # case insensitive, let's make it lowercase to improve readability.
22651       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22652       # Now convert it back to Unix-stile (cygpath)
22653       input_path=`$CYGPATH -u "$shortmode_path"`
22654       new_path="$input_path"
22655     fi
22656   fi
22657 
22658   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22659   if test "x$test_cygdrive_prefix" = x; then
22660     # As a simple fix, exclude /usr/bin since it's not a real path.
22661     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22662       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22663       # a path prefixed by /cygdrive for fixpath to work.
22664       new_path="$CYGWIN_ROOT_PATH$input_path"
22665     fi
22666   fi
22667 
22668 
22669   if test "x$path" != "x$new_path"; then
22670     BOOT_JDK="$new_path"
22671     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22672 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22673   fi
22674 
22675   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22676 
22677   path="$BOOT_JDK"
22678   has_colon=`$ECHO $path | $GREP ^.:`
22679   new_path="$path"
22680   if test "x$has_colon" = x; then
22681     # Not in mixed or Windows style, start by that.
22682     new_path=`cmd //c echo $path`
22683   fi
22684 
22685 
22686   input_path="$new_path"
22687   # Check if we need to convert this using DOS-style short mode. If the path
22688   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22689   # take no chances and rewrite it.
22690   # Note: m4 eats our [], so we need to use [ and ] instead.
22691   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22692   if test "x$has_forbidden_chars" != x; then
22693     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22694     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22695   fi
22696 
22697 
22698   windows_path="$new_path"
22699   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22700     unix_path=`$CYGPATH -u "$windows_path"`
22701     new_path="$unix_path"
22702   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22703     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22704     new_path="$unix_path"
22705   fi
22706 
22707   if test "x$path" != "x$new_path"; then
22708     BOOT_JDK="$new_path"
22709     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22710 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22711   fi
22712 
22713   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22714   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22715 
22716   else
22717     # We're on a posix platform. Hooray! :)
22718     path="$BOOT_JDK"
22719     has_space=`$ECHO "$path" | $GREP " "`
22720     if test "x$has_space" != x; then
22721       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22722 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22723       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22724     fi
22725 
22726     # Use eval to expand a potential ~
22727     eval path="$path"
22728     if test ! -f "$path" && test ! -d "$path"; then
22729       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22730     fi
22731 
22732     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22733   fi
22734 
22735               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22736 $as_echo_n "checking for Boot JDK... " >&6; }
22737               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22738 $as_echo "$BOOT_JDK" >&6; }
22739               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22740 $as_echo_n "checking Boot JDK version... " >&6; }
22741               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22742               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22743 $as_echo "$BOOT_JDK_VERSION" >&6; }
22744             fi # end check jdk version
22745           fi # end check rt.jar
22746         fi # end check javac
22747       fi # end check java
22748     fi # end check boot jdk found
22749   fi
22750 
22751 
22752   if test "x$BOOT_JDK_FOUND" = xno; then
22753     # Now execute the test
22754 
22755   if test "x$PROGRAMFILES" != x; then
22756     VIRTUAL_DIR="$PROGRAMFILES/Java"
22757 
22758   windows_path="$VIRTUAL_DIR"
22759   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22760     unix_path=`$CYGPATH -u "$windows_path"`
22761     VIRTUAL_DIR="$unix_path"
22762   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22763     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22764     VIRTUAL_DIR="$unix_path"
22765   fi
22766 
22767 
22768   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22769   BOOT_JDK_SUFFIX=""
22770   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22771   if test "x$ALL_JDKS_FOUND" != x; then
22772     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22773 
22774   if test "x$BOOT_JDK_FOUND" = xno; then
22775     # Now execute the test
22776 
22777         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22778         if test -d "$BOOT_JDK"; then
22779           BOOT_JDK_FOUND=maybe
22780           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22781 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22782         fi
22783 
22784 
22785     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22786     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22787       # Do we have a bin/java?
22788       if test ! -x "$BOOT_JDK/bin/java"; then
22789         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22790 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22791         BOOT_JDK_FOUND=no
22792       else
22793         # Do we have a bin/javac?
22794         if test ! -x "$BOOT_JDK/bin/javac"; then
22795           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22796 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22797           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22798 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22799           BOOT_JDK_FOUND=no
22800         else
22801           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22802           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22803             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22804 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22805             BOOT_JDK_FOUND=no
22806           else
22807             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22808             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22809 
22810             # Extra M4 quote needed to protect [] in grep expression.
22811             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22812             if test "x$FOUND_CORRECT_VERSION" = x; then
22813               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22814 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22815               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22816 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22817               BOOT_JDK_FOUND=no
22818             else
22819               # We're done! :-)
22820               BOOT_JDK_FOUND=yes
22821 
22822   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22823 
22824   # Input might be given as Windows format, start by converting to
22825   # unix format.
22826   path="$BOOT_JDK"
22827   new_path=`$CYGPATH -u "$path"`
22828 
22829   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22830   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22831   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22832   # "foo.exe" is OK but "foo" is an error.
22833   #
22834   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22835   # It is also a way to make sure we got the proper file name for the real test later on.
22836   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22837   if test "x$test_shortpath" = x; then
22838     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22839 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22840     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22841   fi
22842 
22843   # Call helper function which possibly converts this using DOS-style short mode.
22844   # If so, the updated path is stored in $new_path.
22845 
22846   input_path="$new_path"
22847   # Check if we need to convert this using DOS-style short mode. If the path
22848   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22849   # take no chances and rewrite it.
22850   # Note: m4 eats our [], so we need to use [ and ] instead.
22851   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22852   if test "x$has_forbidden_chars" != x; then
22853     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22854     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22855     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22856     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22857       # Going to short mode and back again did indeed matter. Since short mode is
22858       # case insensitive, let's make it lowercase to improve readability.
22859       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22860       # Now convert it back to Unix-stile (cygpath)
22861       input_path=`$CYGPATH -u "$shortmode_path"`
22862       new_path="$input_path"
22863     fi
22864   fi
22865 
22866   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22867   if test "x$test_cygdrive_prefix" = x; then
22868     # As a simple fix, exclude /usr/bin since it's not a real path.
22869     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22870       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22871       # a path prefixed by /cygdrive for fixpath to work.
22872       new_path="$CYGWIN_ROOT_PATH$input_path"
22873     fi
22874   fi
22875 
22876 
22877   if test "x$path" != "x$new_path"; then
22878     BOOT_JDK="$new_path"
22879     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22880 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22881   fi
22882 
22883   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22884 
22885   path="$BOOT_JDK"
22886   has_colon=`$ECHO $path | $GREP ^.:`
22887   new_path="$path"
22888   if test "x$has_colon" = x; then
22889     # Not in mixed or Windows style, start by that.
22890     new_path=`cmd //c echo $path`
22891   fi
22892 
22893 
22894   input_path="$new_path"
22895   # Check if we need to convert this using DOS-style short mode. If the path
22896   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22897   # take no chances and rewrite it.
22898   # Note: m4 eats our [], so we need to use [ and ] instead.
22899   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22900   if test "x$has_forbidden_chars" != x; then
22901     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22902     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22903   fi
22904 
22905 
22906   windows_path="$new_path"
22907   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22908     unix_path=`$CYGPATH -u "$windows_path"`
22909     new_path="$unix_path"
22910   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22911     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22912     new_path="$unix_path"
22913   fi
22914 
22915   if test "x$path" != "x$new_path"; then
22916     BOOT_JDK="$new_path"
22917     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22918 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22919   fi
22920 
22921   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22922   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22923 
22924   else
22925     # We're on a posix platform. Hooray! :)
22926     path="$BOOT_JDK"
22927     has_space=`$ECHO "$path" | $GREP " "`
22928     if test "x$has_space" != x; then
22929       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22930 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22931       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22932     fi
22933 
22934     # Use eval to expand a potential ~
22935     eval path="$path"
22936     if test ! -f "$path" && test ! -d "$path"; then
22937       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22938     fi
22939 
22940     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22941   fi
22942 
22943               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22944 $as_echo_n "checking for Boot JDK... " >&6; }
22945               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22946 $as_echo "$BOOT_JDK" >&6; }
22947               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22948 $as_echo_n "checking Boot JDK version... " >&6; }
22949               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22950               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22951 $as_echo "$BOOT_JDK_VERSION" >&6; }
22952             fi # end check jdk version
22953           fi # end check rt.jar
22954         fi # end check javac
22955       fi # end check java
22956     fi # end check boot jdk found
22957   fi
22958 
22959     done
22960   fi
22961 
22962   fi
22963 
22964 
22965     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22966     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22967       # Do we have a bin/java?
22968       if test ! -x "$BOOT_JDK/bin/java"; then
22969         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22970 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22971         BOOT_JDK_FOUND=no
22972       else
22973         # Do we have a bin/javac?
22974         if test ! -x "$BOOT_JDK/bin/javac"; then
22975           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22976 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22977           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22978 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22979           BOOT_JDK_FOUND=no
22980         else
22981           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22982           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22983             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22984 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22985             BOOT_JDK_FOUND=no
22986           else
22987             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22988             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22989 
22990             # Extra M4 quote needed to protect [] in grep expression.
22991             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22992             if test "x$FOUND_CORRECT_VERSION" = x; then
22993               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22994 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22995               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22996 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22997               BOOT_JDK_FOUND=no
22998             else
22999               # We're done! :-)
23000               BOOT_JDK_FOUND=yes
23001 
23002   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23003 
23004   # Input might be given as Windows format, start by converting to
23005   # unix format.
23006   path="$BOOT_JDK"
23007   new_path=`$CYGPATH -u "$path"`
23008 
23009   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23010   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23011   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23012   # "foo.exe" is OK but "foo" is an error.
23013   #
23014   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23015   # It is also a way to make sure we got the proper file name for the real test later on.
23016   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23017   if test "x$test_shortpath" = x; then
23018     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23019 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23020     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23021   fi
23022 
23023   # Call helper function which possibly converts this using DOS-style short mode.
23024   # If so, the updated path is stored in $new_path.
23025 
23026   input_path="$new_path"
23027   # Check if we need to convert this using DOS-style short mode. If the path
23028   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23029   # take no chances and rewrite it.
23030   # Note: m4 eats our [], so we need to use [ and ] instead.
23031   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23032   if test "x$has_forbidden_chars" != x; then
23033     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23034     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23035     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23036     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23037       # Going to short mode and back again did indeed matter. Since short mode is
23038       # case insensitive, let's make it lowercase to improve readability.
23039       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23040       # Now convert it back to Unix-stile (cygpath)
23041       input_path=`$CYGPATH -u "$shortmode_path"`
23042       new_path="$input_path"
23043     fi
23044   fi
23045 
23046   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23047   if test "x$test_cygdrive_prefix" = x; then
23048     # As a simple fix, exclude /usr/bin since it's not a real path.
23049     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23050       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23051       # a path prefixed by /cygdrive for fixpath to work.
23052       new_path="$CYGWIN_ROOT_PATH$input_path"
23053     fi
23054   fi
23055 
23056 
23057   if test "x$path" != "x$new_path"; then
23058     BOOT_JDK="$new_path"
23059     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23060 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23061   fi
23062 
23063   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23064 
23065   path="$BOOT_JDK"
23066   has_colon=`$ECHO $path | $GREP ^.:`
23067   new_path="$path"
23068   if test "x$has_colon" = x; then
23069     # Not in mixed or Windows style, start by that.
23070     new_path=`cmd //c echo $path`
23071   fi
23072 
23073 
23074   input_path="$new_path"
23075   # Check if we need to convert this using DOS-style short mode. If the path
23076   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23077   # take no chances and rewrite it.
23078   # Note: m4 eats our [], so we need to use [ and ] instead.
23079   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23080   if test "x$has_forbidden_chars" != x; then
23081     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23082     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23083   fi
23084 
23085 
23086   windows_path="$new_path"
23087   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23088     unix_path=`$CYGPATH -u "$windows_path"`
23089     new_path="$unix_path"
23090   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23091     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23092     new_path="$unix_path"
23093   fi
23094 
23095   if test "x$path" != "x$new_path"; then
23096     BOOT_JDK="$new_path"
23097     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23098 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23099   fi
23100 
23101   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23102   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23103 
23104   else
23105     # We're on a posix platform. Hooray! :)
23106     path="$BOOT_JDK"
23107     has_space=`$ECHO "$path" | $GREP " "`
23108     if test "x$has_space" != x; then
23109       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23110 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23111       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23112     fi
23113 
23114     # Use eval to expand a potential ~
23115     eval path="$path"
23116     if test ! -f "$path" && test ! -d "$path"; then
23117       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23118     fi
23119 
23120     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23121   fi
23122 
23123               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23124 $as_echo_n "checking for Boot JDK... " >&6; }
23125               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23126 $as_echo "$BOOT_JDK" >&6; }
23127               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23128 $as_echo_n "checking Boot JDK version... " >&6; }
23129               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23130               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23131 $as_echo "$BOOT_JDK_VERSION" >&6; }
23132             fi # end check jdk version
23133           fi # end check rt.jar
23134         fi # end check javac
23135       fi # end check java
23136     fi # end check boot jdk found
23137   fi
23138 
23139 
23140   if test "x$BOOT_JDK_FOUND" = xno; then
23141     # Now execute the test
23142 
23143   if test "x$ProgramFiles" != x; then
23144     VIRTUAL_DIR="$ProgramFiles/Java"
23145 
23146   windows_path="$VIRTUAL_DIR"
23147   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23148     unix_path=`$CYGPATH -u "$windows_path"`
23149     VIRTUAL_DIR="$unix_path"
23150   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23151     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23152     VIRTUAL_DIR="$unix_path"
23153   fi
23154 
23155 
23156   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
23157   BOOT_JDK_SUFFIX=""
23158   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23159   if test "x$ALL_JDKS_FOUND" != x; then
23160     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23161 
23162   if test "x$BOOT_JDK_FOUND" = xno; then
23163     # Now execute the test
23164 
23165         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23166         if test -d "$BOOT_JDK"; then
23167           BOOT_JDK_FOUND=maybe
23168           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23169 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23170         fi
23171 
23172 
23173     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23174     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23175       # Do we have a bin/java?
23176       if test ! -x "$BOOT_JDK/bin/java"; then
23177         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23178 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23179         BOOT_JDK_FOUND=no
23180       else
23181         # Do we have a bin/javac?
23182         if test ! -x "$BOOT_JDK/bin/javac"; then
23183           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23184 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23185           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23186 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23187           BOOT_JDK_FOUND=no
23188         else
23189           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23190           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23191             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23192 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23193             BOOT_JDK_FOUND=no
23194           else
23195             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23196             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23197 
23198             # Extra M4 quote needed to protect [] in grep expression.
23199             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23200             if test "x$FOUND_CORRECT_VERSION" = x; then
23201               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23202 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23203               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23204 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23205               BOOT_JDK_FOUND=no
23206             else
23207               # We're done! :-)
23208               BOOT_JDK_FOUND=yes
23209 
23210   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23211 
23212   # Input might be given as Windows format, start by converting to
23213   # unix format.
23214   path="$BOOT_JDK"
23215   new_path=`$CYGPATH -u "$path"`
23216 
23217   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23218   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23219   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23220   # "foo.exe" is OK but "foo" is an error.
23221   #
23222   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23223   # It is also a way to make sure we got the proper file name for the real test later on.
23224   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23225   if test "x$test_shortpath" = x; then
23226     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23227 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23228     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23229   fi
23230 
23231   # Call helper function which possibly converts this using DOS-style short mode.
23232   # If so, the updated path is stored in $new_path.
23233 
23234   input_path="$new_path"
23235   # Check if we need to convert this using DOS-style short mode. If the path
23236   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23237   # take no chances and rewrite it.
23238   # Note: m4 eats our [], so we need to use [ and ] instead.
23239   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23240   if test "x$has_forbidden_chars" != x; then
23241     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23242     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23243     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23244     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23245       # Going to short mode and back again did indeed matter. Since short mode is
23246       # case insensitive, let's make it lowercase to improve readability.
23247       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23248       # Now convert it back to Unix-stile (cygpath)
23249       input_path=`$CYGPATH -u "$shortmode_path"`
23250       new_path="$input_path"
23251     fi
23252   fi
23253 
23254   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23255   if test "x$test_cygdrive_prefix" = x; then
23256     # As a simple fix, exclude /usr/bin since it's not a real path.
23257     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23258       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23259       # a path prefixed by /cygdrive for fixpath to work.
23260       new_path="$CYGWIN_ROOT_PATH$input_path"
23261     fi
23262   fi
23263 
23264 
23265   if test "x$path" != "x$new_path"; then
23266     BOOT_JDK="$new_path"
23267     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23268 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23269   fi
23270 
23271   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23272 
23273   path="$BOOT_JDK"
23274   has_colon=`$ECHO $path | $GREP ^.:`
23275   new_path="$path"
23276   if test "x$has_colon" = x; then
23277     # Not in mixed or Windows style, start by that.
23278     new_path=`cmd //c echo $path`
23279   fi
23280 
23281 
23282   input_path="$new_path"
23283   # Check if we need to convert this using DOS-style short mode. If the path
23284   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23285   # take no chances and rewrite it.
23286   # Note: m4 eats our [], so we need to use [ and ] instead.
23287   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23288   if test "x$has_forbidden_chars" != x; then
23289     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23290     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23291   fi
23292 
23293 
23294   windows_path="$new_path"
23295   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23296     unix_path=`$CYGPATH -u "$windows_path"`
23297     new_path="$unix_path"
23298   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23299     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23300     new_path="$unix_path"
23301   fi
23302 
23303   if test "x$path" != "x$new_path"; then
23304     BOOT_JDK="$new_path"
23305     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23306 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23307   fi
23308 
23309   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23310   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23311 
23312   else
23313     # We're on a posix platform. Hooray! :)
23314     path="$BOOT_JDK"
23315     has_space=`$ECHO "$path" | $GREP " "`
23316     if test "x$has_space" != x; then
23317       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23318 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23319       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23320     fi
23321 
23322     # Use eval to expand a potential ~
23323     eval path="$path"
23324     if test ! -f "$path" && test ! -d "$path"; then
23325       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23326     fi
23327 
23328     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23329   fi
23330 
23331               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23332 $as_echo_n "checking for Boot JDK... " >&6; }
23333               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23334 $as_echo "$BOOT_JDK" >&6; }
23335               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23336 $as_echo_n "checking Boot JDK version... " >&6; }
23337               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23338               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23339 $as_echo "$BOOT_JDK_VERSION" >&6; }
23340             fi # end check jdk version
23341           fi # end check rt.jar
23342         fi # end check javac
23343       fi # end check java
23344     fi # end check boot jdk found
23345   fi
23346 
23347     done
23348   fi
23349 
23350   fi
23351 
23352 
23353     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23354     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23355       # Do we have a bin/java?
23356       if test ! -x "$BOOT_JDK/bin/java"; then
23357         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23358 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23359         BOOT_JDK_FOUND=no
23360       else
23361         # Do we have a bin/javac?
23362         if test ! -x "$BOOT_JDK/bin/javac"; then
23363           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23364 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23365           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23366 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23367           BOOT_JDK_FOUND=no
23368         else
23369           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23370           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23371             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23372 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23373             BOOT_JDK_FOUND=no
23374           else
23375             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23376             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23377 
23378             # Extra M4 quote needed to protect [] in grep expression.
23379             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23380             if test "x$FOUND_CORRECT_VERSION" = x; then
23381               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23382 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23383               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23384 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23385               BOOT_JDK_FOUND=no
23386             else
23387               # We're done! :-)
23388               BOOT_JDK_FOUND=yes
23389 
23390   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23391 
23392   # Input might be given as Windows format, start by converting to
23393   # unix format.
23394   path="$BOOT_JDK"
23395   new_path=`$CYGPATH -u "$path"`
23396 
23397   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23398   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23399   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23400   # "foo.exe" is OK but "foo" is an error.
23401   #
23402   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23403   # It is also a way to make sure we got the proper file name for the real test later on.
23404   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23405   if test "x$test_shortpath" = x; then
23406     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23407 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23408     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23409   fi
23410 
23411   # Call helper function which possibly converts this using DOS-style short mode.
23412   # If so, the updated path is stored in $new_path.
23413 
23414   input_path="$new_path"
23415   # Check if we need to convert this using DOS-style short mode. If the path
23416   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23417   # take no chances and rewrite it.
23418   # Note: m4 eats our [], so we need to use [ and ] instead.
23419   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23420   if test "x$has_forbidden_chars" != x; then
23421     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23422     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23423     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23424     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23425       # Going to short mode and back again did indeed matter. Since short mode is
23426       # case insensitive, let's make it lowercase to improve readability.
23427       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23428       # Now convert it back to Unix-stile (cygpath)
23429       input_path=`$CYGPATH -u "$shortmode_path"`
23430       new_path="$input_path"
23431     fi
23432   fi
23433 
23434   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23435   if test "x$test_cygdrive_prefix" = x; then
23436     # As a simple fix, exclude /usr/bin since it's not a real path.
23437     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23438       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23439       # a path prefixed by /cygdrive for fixpath to work.
23440       new_path="$CYGWIN_ROOT_PATH$input_path"
23441     fi
23442   fi
23443 
23444 
23445   if test "x$path" != "x$new_path"; then
23446     BOOT_JDK="$new_path"
23447     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23448 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23449   fi
23450 
23451   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23452 
23453   path="$BOOT_JDK"
23454   has_colon=`$ECHO $path | $GREP ^.:`
23455   new_path="$path"
23456   if test "x$has_colon" = x; then
23457     # Not in mixed or Windows style, start by that.
23458     new_path=`cmd //c echo $path`
23459   fi
23460 
23461 
23462   input_path="$new_path"
23463   # Check if we need to convert this using DOS-style short mode. If the path
23464   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23465   # take no chances and rewrite it.
23466   # Note: m4 eats our [], so we need to use [ and ] instead.
23467   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23468   if test "x$has_forbidden_chars" != x; then
23469     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23470     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23471   fi
23472 
23473 
23474   windows_path="$new_path"
23475   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23476     unix_path=`$CYGPATH -u "$windows_path"`
23477     new_path="$unix_path"
23478   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23479     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23480     new_path="$unix_path"
23481   fi
23482 
23483   if test "x$path" != "x$new_path"; then
23484     BOOT_JDK="$new_path"
23485     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23486 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23487   fi
23488 
23489   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23490   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23491 
23492   else
23493     # We're on a posix platform. Hooray! :)
23494     path="$BOOT_JDK"
23495     has_space=`$ECHO "$path" | $GREP " "`
23496     if test "x$has_space" != x; then
23497       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23498 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23499       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23500     fi
23501 
23502     # Use eval to expand a potential ~
23503     eval path="$path"
23504     if test ! -f "$path" && test ! -d "$path"; then
23505       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23506     fi
23507 
23508     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23509   fi
23510 
23511               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23512 $as_echo_n "checking for Boot JDK... " >&6; }
23513               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23514 $as_echo "$BOOT_JDK" >&6; }
23515               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23516 $as_echo_n "checking Boot JDK version... " >&6; }
23517               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23518               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23519 $as_echo "$BOOT_JDK_VERSION" >&6; }
23520             fi # end check jdk version
23521           fi # end check rt.jar
23522         fi # end check javac
23523       fi # end check java
23524     fi # end check boot jdk found
23525   fi
23526 
23527 
23528   if test "x$BOOT_JDK_FOUND" = xno; then
23529     # Now execute the test
23530 
23531   BOOT_JDK_PREFIX="/cygdrive/c/Program Files/Java"
23532   BOOT_JDK_SUFFIX=""
23533   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23534   if test "x$ALL_JDKS_FOUND" != x; then
23535     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23536 
23537   if test "x$BOOT_JDK_FOUND" = xno; then
23538     # Now execute the test
23539 
23540         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23541         if test -d "$BOOT_JDK"; then
23542           BOOT_JDK_FOUND=maybe
23543           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23544 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23545         fi
23546 
23547 
23548     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23549     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23550       # Do we have a bin/java?
23551       if test ! -x "$BOOT_JDK/bin/java"; then
23552         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23553 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23554         BOOT_JDK_FOUND=no
23555       else
23556         # Do we have a bin/javac?
23557         if test ! -x "$BOOT_JDK/bin/javac"; then
23558           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23559 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23560           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23561 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23562           BOOT_JDK_FOUND=no
23563         else
23564           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23565           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23566             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23567 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23568             BOOT_JDK_FOUND=no
23569           else
23570             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23571             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23572 
23573             # Extra M4 quote needed to protect [] in grep expression.
23574             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23575             if test "x$FOUND_CORRECT_VERSION" = x; then
23576               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23577 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23578               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23579 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23580               BOOT_JDK_FOUND=no
23581             else
23582               # We're done! :-)
23583               BOOT_JDK_FOUND=yes
23584 
23585   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23586 
23587   # Input might be given as Windows format, start by converting to
23588   # unix format.
23589   path="$BOOT_JDK"
23590   new_path=`$CYGPATH -u "$path"`
23591 
23592   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23593   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23594   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23595   # "foo.exe" is OK but "foo" is an error.
23596   #
23597   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23598   # It is also a way to make sure we got the proper file name for the real test later on.
23599   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23600   if test "x$test_shortpath" = x; then
23601     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23602 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23603     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23604   fi
23605 
23606   # Call helper function which possibly converts this using DOS-style short mode.
23607   # If so, the updated path is stored in $new_path.
23608 
23609   input_path="$new_path"
23610   # Check if we need to convert this using DOS-style short mode. If the path
23611   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23612   # take no chances and rewrite it.
23613   # Note: m4 eats our [], so we need to use [ and ] instead.
23614   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23615   if test "x$has_forbidden_chars" != x; then
23616     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23617     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23618     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23619     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23620       # Going to short mode and back again did indeed matter. Since short mode is
23621       # case insensitive, let's make it lowercase to improve readability.
23622       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23623       # Now convert it back to Unix-stile (cygpath)
23624       input_path=`$CYGPATH -u "$shortmode_path"`
23625       new_path="$input_path"
23626     fi
23627   fi
23628 
23629   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23630   if test "x$test_cygdrive_prefix" = x; then
23631     # As a simple fix, exclude /usr/bin since it's not a real path.
23632     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23633       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23634       # a path prefixed by /cygdrive for fixpath to work.
23635       new_path="$CYGWIN_ROOT_PATH$input_path"
23636     fi
23637   fi
23638 
23639 
23640   if test "x$path" != "x$new_path"; then
23641     BOOT_JDK="$new_path"
23642     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23643 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23644   fi
23645 
23646   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23647 
23648   path="$BOOT_JDK"
23649   has_colon=`$ECHO $path | $GREP ^.:`
23650   new_path="$path"
23651   if test "x$has_colon" = x; then
23652     # Not in mixed or Windows style, start by that.
23653     new_path=`cmd //c echo $path`
23654   fi
23655 
23656 
23657   input_path="$new_path"
23658   # Check if we need to convert this using DOS-style short mode. If the path
23659   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23660   # take no chances and rewrite it.
23661   # Note: m4 eats our [], so we need to use [ and ] instead.
23662   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23663   if test "x$has_forbidden_chars" != x; then
23664     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23665     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23666   fi
23667 
23668 
23669   windows_path="$new_path"
23670   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23671     unix_path=`$CYGPATH -u "$windows_path"`
23672     new_path="$unix_path"
23673   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23674     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23675     new_path="$unix_path"
23676   fi
23677 
23678   if test "x$path" != "x$new_path"; then
23679     BOOT_JDK="$new_path"
23680     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23681 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23682   fi
23683 
23684   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23685   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23686 
23687   else
23688     # We're on a posix platform. Hooray! :)
23689     path="$BOOT_JDK"
23690     has_space=`$ECHO "$path" | $GREP " "`
23691     if test "x$has_space" != x; then
23692       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23693 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23694       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23695     fi
23696 
23697     # Use eval to expand a potential ~
23698     eval path="$path"
23699     if test ! -f "$path" && test ! -d "$path"; then
23700       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23701     fi
23702 
23703     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23704   fi
23705 
23706               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23707 $as_echo_n "checking for Boot JDK... " >&6; }
23708               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23709 $as_echo "$BOOT_JDK" >&6; }
23710               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23711 $as_echo_n "checking Boot JDK version... " >&6; }
23712               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23713               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23714 $as_echo "$BOOT_JDK_VERSION" >&6; }
23715             fi # end check jdk version
23716           fi # end check rt.jar
23717         fi # end check javac
23718       fi # end check java
23719     fi # end check boot jdk found
23720   fi
23721 
23722     done
23723   fi
23724 
23725 
23726     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23727     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23728       # Do we have a bin/java?
23729       if test ! -x "$BOOT_JDK/bin/java"; then
23730         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23731 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23732         BOOT_JDK_FOUND=no
23733       else
23734         # Do we have a bin/javac?
23735         if test ! -x "$BOOT_JDK/bin/javac"; then
23736           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23737 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23738           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23739 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23740           BOOT_JDK_FOUND=no
23741         else
23742           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23743           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23744             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23745 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23746             BOOT_JDK_FOUND=no
23747           else
23748             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23749             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23750 
23751             # Extra M4 quote needed to protect [] in grep expression.
23752             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23753             if test "x$FOUND_CORRECT_VERSION" = x; then
23754               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23755 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23756               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23757 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23758               BOOT_JDK_FOUND=no
23759             else
23760               # We're done! :-)
23761               BOOT_JDK_FOUND=yes
23762 
23763   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23764 
23765   # Input might be given as Windows format, start by converting to
23766   # unix format.
23767   path="$BOOT_JDK"
23768   new_path=`$CYGPATH -u "$path"`
23769 
23770   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23771   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23772   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23773   # "foo.exe" is OK but "foo" is an error.
23774   #
23775   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23776   # It is also a way to make sure we got the proper file name for the real test later on.
23777   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23778   if test "x$test_shortpath" = x; then
23779     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23780 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23781     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23782   fi
23783 
23784   # Call helper function which possibly converts this using DOS-style short mode.
23785   # If so, the updated path is stored in $new_path.
23786 
23787   input_path="$new_path"
23788   # Check if we need to convert this using DOS-style short mode. If the path
23789   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23790   # take no chances and rewrite it.
23791   # Note: m4 eats our [], so we need to use [ and ] instead.
23792   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23793   if test "x$has_forbidden_chars" != x; then
23794     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23795     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23796     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23797     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23798       # Going to short mode and back again did indeed matter. Since short mode is
23799       # case insensitive, let's make it lowercase to improve readability.
23800       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23801       # Now convert it back to Unix-stile (cygpath)
23802       input_path=`$CYGPATH -u "$shortmode_path"`
23803       new_path="$input_path"
23804     fi
23805   fi
23806 
23807   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23808   if test "x$test_cygdrive_prefix" = x; then
23809     # As a simple fix, exclude /usr/bin since it's not a real path.
23810     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23811       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23812       # a path prefixed by /cygdrive for fixpath to work.
23813       new_path="$CYGWIN_ROOT_PATH$input_path"
23814     fi
23815   fi
23816 
23817 
23818   if test "x$path" != "x$new_path"; then
23819     BOOT_JDK="$new_path"
23820     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23821 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23822   fi
23823 
23824   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23825 
23826   path="$BOOT_JDK"
23827   has_colon=`$ECHO $path | $GREP ^.:`
23828   new_path="$path"
23829   if test "x$has_colon" = x; then
23830     # Not in mixed or Windows style, start by that.
23831     new_path=`cmd //c echo $path`
23832   fi
23833 
23834 
23835   input_path="$new_path"
23836   # Check if we need to convert this using DOS-style short mode. If the path
23837   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23838   # take no chances and rewrite it.
23839   # Note: m4 eats our [], so we need to use [ and ] instead.
23840   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23841   if test "x$has_forbidden_chars" != x; then
23842     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23843     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23844   fi
23845 
23846 
23847   windows_path="$new_path"
23848   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23849     unix_path=`$CYGPATH -u "$windows_path"`
23850     new_path="$unix_path"
23851   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23852     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23853     new_path="$unix_path"
23854   fi
23855 
23856   if test "x$path" != "x$new_path"; then
23857     BOOT_JDK="$new_path"
23858     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23859 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23860   fi
23861 
23862   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23863   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23864 
23865   else
23866     # We're on a posix platform. Hooray! :)
23867     path="$BOOT_JDK"
23868     has_space=`$ECHO "$path" | $GREP " "`
23869     if test "x$has_space" != x; then
23870       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23871 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23872       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23873     fi
23874 
23875     # Use eval to expand a potential ~
23876     eval path="$path"
23877     if test ! -f "$path" && test ! -d "$path"; then
23878       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23879     fi
23880 
23881     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23882   fi
23883 
23884               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23885 $as_echo_n "checking for Boot JDK... " >&6; }
23886               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23887 $as_echo "$BOOT_JDK" >&6; }
23888               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23889 $as_echo_n "checking Boot JDK version... " >&6; }
23890               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23891               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23892 $as_echo "$BOOT_JDK_VERSION" >&6; }
23893             fi # end check jdk version
23894           fi # end check rt.jar
23895         fi # end check javac
23896       fi # end check java
23897     fi # end check boot jdk found
23898   fi
23899 
23900   elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
23901 
23902   if test "x$BOOT_JDK_FOUND" = xno; then
23903     # Now execute the test
23904 
23905   BOOT_JDK_PREFIX="/Library/Java/JavaVirtualMachines"
23906   BOOT_JDK_SUFFIX="/Contents/Home"
23907   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23908   if test "x$ALL_JDKS_FOUND" != x; then
23909     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23910 
23911   if test "x$BOOT_JDK_FOUND" = xno; then
23912     # Now execute the test
23913 
23914         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23915         if test -d "$BOOT_JDK"; then
23916           BOOT_JDK_FOUND=maybe
23917           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23918 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23919         fi
23920 
23921 
23922     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23923     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23924       # Do we have a bin/java?
23925       if test ! -x "$BOOT_JDK/bin/java"; then
23926         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23927 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23928         BOOT_JDK_FOUND=no
23929       else
23930         # Do we have a bin/javac?
23931         if test ! -x "$BOOT_JDK/bin/javac"; then
23932           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23933 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23934           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23935 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23936           BOOT_JDK_FOUND=no
23937         else
23938           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23939           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23940             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23941 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23942             BOOT_JDK_FOUND=no
23943           else
23944             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23945             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23946 
23947             # Extra M4 quote needed to protect [] in grep expression.
23948             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23949             if test "x$FOUND_CORRECT_VERSION" = x; then
23950               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23951 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23952               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23953 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23954               BOOT_JDK_FOUND=no
23955             else
23956               # We're done! :-)
23957               BOOT_JDK_FOUND=yes
23958 
23959   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23960 
23961   # Input might be given as Windows format, start by converting to
23962   # unix format.
23963   path="$BOOT_JDK"
23964   new_path=`$CYGPATH -u "$path"`
23965 
23966   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23967   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23968   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23969   # "foo.exe" is OK but "foo" is an error.
23970   #
23971   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23972   # It is also a way to make sure we got the proper file name for the real test later on.
23973   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23974   if test "x$test_shortpath" = x; then
23975     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23976 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23977     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23978   fi
23979 
23980   # Call helper function which possibly converts this using DOS-style short mode.
23981   # If so, the updated path is stored in $new_path.
23982 
23983   input_path="$new_path"
23984   # Check if we need to convert this using DOS-style short mode. If the path
23985   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23986   # take no chances and rewrite it.
23987   # Note: m4 eats our [], so we need to use [ and ] instead.
23988   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23989   if test "x$has_forbidden_chars" != x; then
23990     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23991     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23992     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23993     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23994       # Going to short mode and back again did indeed matter. Since short mode is
23995       # case insensitive, let's make it lowercase to improve readability.
23996       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23997       # Now convert it back to Unix-stile (cygpath)
23998       input_path=`$CYGPATH -u "$shortmode_path"`
23999       new_path="$input_path"
24000     fi
24001   fi
24002 
24003   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24004   if test "x$test_cygdrive_prefix" = x; then
24005     # As a simple fix, exclude /usr/bin since it's not a real path.
24006     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24007       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24008       # a path prefixed by /cygdrive for fixpath to work.
24009       new_path="$CYGWIN_ROOT_PATH$input_path"
24010     fi
24011   fi
24012 
24013 
24014   if test "x$path" != "x$new_path"; then
24015     BOOT_JDK="$new_path"
24016     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24017 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24018   fi
24019 
24020   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24021 
24022   path="$BOOT_JDK"
24023   has_colon=`$ECHO $path | $GREP ^.:`
24024   new_path="$path"
24025   if test "x$has_colon" = x; then
24026     # Not in mixed or Windows style, start by that.
24027     new_path=`cmd //c echo $path`
24028   fi
24029 
24030 
24031   input_path="$new_path"
24032   # Check if we need to convert this using DOS-style short mode. If the path
24033   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24034   # take no chances and rewrite it.
24035   # Note: m4 eats our [], so we need to use [ and ] instead.
24036   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24037   if test "x$has_forbidden_chars" != x; then
24038     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24039     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24040   fi
24041 
24042 
24043   windows_path="$new_path"
24044   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24045     unix_path=`$CYGPATH -u "$windows_path"`
24046     new_path="$unix_path"
24047   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24048     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24049     new_path="$unix_path"
24050   fi
24051 
24052   if test "x$path" != "x$new_path"; then
24053     BOOT_JDK="$new_path"
24054     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24055 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24056   fi
24057 
24058   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24059   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24060 
24061   else
24062     # We're on a posix platform. Hooray! :)
24063     path="$BOOT_JDK"
24064     has_space=`$ECHO "$path" | $GREP " "`
24065     if test "x$has_space" != x; then
24066       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24067 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24068       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24069     fi
24070 
24071     # Use eval to expand a potential ~
24072     eval path="$path"
24073     if test ! -f "$path" && test ! -d "$path"; then
24074       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24075     fi
24076 
24077     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24078   fi
24079 
24080               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24081 $as_echo_n "checking for Boot JDK... " >&6; }
24082               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24083 $as_echo "$BOOT_JDK" >&6; }
24084               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24085 $as_echo_n "checking Boot JDK version... " >&6; }
24086               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24087               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24088 $as_echo "$BOOT_JDK_VERSION" >&6; }
24089             fi # end check jdk version
24090           fi # end check rt.jar
24091         fi # end check javac
24092       fi # end check java
24093     fi # end check boot jdk found
24094   fi
24095 
24096     done
24097   fi
24098 
24099 
24100     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24101     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24102       # Do we have a bin/java?
24103       if test ! -x "$BOOT_JDK/bin/java"; then
24104         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24105 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24106         BOOT_JDK_FOUND=no
24107       else
24108         # Do we have a bin/javac?
24109         if test ! -x "$BOOT_JDK/bin/javac"; then
24110           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24111 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24112           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24113 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24114           BOOT_JDK_FOUND=no
24115         else
24116           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
24117           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
24118             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
24119 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
24120             BOOT_JDK_FOUND=no
24121           else
24122             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24123             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24124 
24125             # Extra M4 quote needed to protect [] in grep expression.
24126             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24127             if test "x$FOUND_CORRECT_VERSION" = x; then
24128               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24129 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24130               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24131 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24132               BOOT_JDK_FOUND=no
24133             else
24134               # We're done! :-)
24135               BOOT_JDK_FOUND=yes
24136 
24137   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24138 
24139   # Input might be given as Windows format, start by converting to
24140   # unix format.
24141   path="$BOOT_JDK"
24142   new_path=`$CYGPATH -u "$path"`
24143 
24144   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24145   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24146   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24147   # "foo.exe" is OK but "foo" is an error.
24148   #
24149   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24150   # It is also a way to make sure we got the proper file name for the real test later on.
24151   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24152   if test "x$test_shortpath" = x; then
24153     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24154 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24155     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24156   fi
24157 
24158   # Call helper function which possibly converts this using DOS-style short mode.
24159   # If so, the updated path is stored in $new_path.
24160 
24161   input_path="$new_path"
24162   # Check if we need to convert this using DOS-style short mode. If the path
24163   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24164   # take no chances and rewrite it.
24165   # Note: m4 eats our [], so we need to use [ and ] instead.
24166   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24167   if test "x$has_forbidden_chars" != x; then
24168     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24169     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24170     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24171     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24172       # Going to short mode and back again did indeed matter. Since short mode is
24173       # case insensitive, let's make it lowercase to improve readability.
24174       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24175       # Now convert it back to Unix-stile (cygpath)
24176       input_path=`$CYGPATH -u "$shortmode_path"`
24177       new_path="$input_path"
24178     fi
24179   fi
24180 
24181   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24182   if test "x$test_cygdrive_prefix" = x; then
24183     # As a simple fix, exclude /usr/bin since it's not a real path.
24184     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24185       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24186       # a path prefixed by /cygdrive for fixpath to work.
24187       new_path="$CYGWIN_ROOT_PATH$input_path"
24188     fi
24189   fi
24190 
24191 
24192   if test "x$path" != "x$new_path"; then
24193     BOOT_JDK="$new_path"
24194     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24195 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24196   fi
24197 
24198   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24199 
24200   path="$BOOT_JDK"
24201   has_colon=`$ECHO $path | $GREP ^.:`
24202   new_path="$path"
24203   if test "x$has_colon" = x; then
24204     # Not in mixed or Windows style, start by that.
24205     new_path=`cmd //c echo $path`
24206   fi
24207 
24208 
24209   input_path="$new_path"
24210   # Check if we need to convert this using DOS-style short mode. If the path
24211   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24212   # take no chances and rewrite it.
24213   # Note: m4 eats our [], so we need to use [ and ] instead.
24214   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24215   if test "x$has_forbidden_chars" != x; then
24216     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24217     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24218   fi
24219 
24220 
24221   windows_path="$new_path"
24222   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24223     unix_path=`$CYGPATH -u "$windows_path"`
24224     new_path="$unix_path"
24225   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24226     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24227     new_path="$unix_path"
24228   fi
24229 
24230   if test "x$path" != "x$new_path"; then
24231     BOOT_JDK="$new_path"
24232     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24233 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24234   fi
24235 
24236   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24237   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24238 
24239   else
24240     # We're on a posix platform. Hooray! :)
24241     path="$BOOT_JDK"
24242     has_space=`$ECHO "$path" | $GREP " "`
24243     if test "x$has_space" != x; then
24244       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24245 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24246       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24247     fi
24248 
24249     # Use eval to expand a potential ~
24250     eval path="$path"
24251     if test ! -f "$path" && test ! -d "$path"; then
24252       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24253     fi
24254 
24255     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24256   fi
24257 
24258               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24259 $as_echo_n "checking for Boot JDK... " >&6; }
24260               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24261 $as_echo "$BOOT_JDK" >&6; }
24262               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24263 $as_echo_n "checking Boot JDK version... " >&6; }
24264               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24265               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24266 $as_echo "$BOOT_JDK_VERSION" >&6; }
24267             fi # end check jdk version
24268           fi # end check rt.jar
24269         fi # end check javac
24270       fi # end check java
24271     fi # end check boot jdk found
24272   fi
24273 
24274 
24275   if test "x$BOOT_JDK_FOUND" = xno; then
24276     # Now execute the test
24277 
24278   BOOT_JDK_PREFIX="/System/Library/Java/JavaVirtualMachines"
24279   BOOT_JDK_SUFFIX="/Contents/Home"
24280   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24281   if test "x$ALL_JDKS_FOUND" != x; then
24282     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24283 
24284   if test "x$BOOT_JDK_FOUND" = xno; then
24285     # Now execute the test
24286 
24287         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24288         if test -d "$BOOT_JDK"; then
24289           BOOT_JDK_FOUND=maybe
24290           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24291 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24292         fi
24293 
24294 
24295     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24296     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24297       # Do we have a bin/java?
24298       if test ! -x "$BOOT_JDK/bin/java"; then
24299         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24300 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24301         BOOT_JDK_FOUND=no
24302       else
24303         # Do we have a bin/javac?
24304         if test ! -x "$BOOT_JDK/bin/javac"; then
24305           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24306 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24307           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24308 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24309           BOOT_JDK_FOUND=no
24310         else
24311           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
24312           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
24313             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
24314 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
24315             BOOT_JDK_FOUND=no
24316           else
24317             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24318             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24319 
24320             # Extra M4 quote needed to protect [] in grep expression.
24321             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24322             if test "x$FOUND_CORRECT_VERSION" = x; then
24323               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24324 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24325               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24326 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24327               BOOT_JDK_FOUND=no
24328             else
24329               # We're done! :-)
24330               BOOT_JDK_FOUND=yes
24331 
24332   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24333 
24334   # Input might be given as Windows format, start by converting to
24335   # unix format.
24336   path="$BOOT_JDK"
24337   new_path=`$CYGPATH -u "$path"`
24338 
24339   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24340   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24341   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24342   # "foo.exe" is OK but "foo" is an error.
24343   #
24344   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24345   # It is also a way to make sure we got the proper file name for the real test later on.
24346   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24347   if test "x$test_shortpath" = x; then
24348     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24349 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24350     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24351   fi
24352 
24353   # Call helper function which possibly converts this using DOS-style short mode.
24354   # If so, the updated path is stored in $new_path.
24355 
24356   input_path="$new_path"
24357   # Check if we need to convert this using DOS-style short mode. If the path
24358   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24359   # take no chances and rewrite it.
24360   # Note: m4 eats our [], so we need to use [ and ] instead.
24361   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24362   if test "x$has_forbidden_chars" != x; then
24363     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24364     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24365     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24366     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24367       # Going to short mode and back again did indeed matter. Since short mode is
24368       # case insensitive, let's make it lowercase to improve readability.
24369       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24370       # Now convert it back to Unix-stile (cygpath)
24371       input_path=`$CYGPATH -u "$shortmode_path"`
24372       new_path="$input_path"
24373     fi
24374   fi
24375 
24376   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24377   if test "x$test_cygdrive_prefix" = x; then
24378     # As a simple fix, exclude /usr/bin since it's not a real path.
24379     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24380       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24381       # a path prefixed by /cygdrive for fixpath to work.
24382       new_path="$CYGWIN_ROOT_PATH$input_path"
24383     fi
24384   fi
24385 
24386 
24387   if test "x$path" != "x$new_path"; then
24388     BOOT_JDK="$new_path"
24389     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24390 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24391   fi
24392 
24393   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24394 
24395   path="$BOOT_JDK"
24396   has_colon=`$ECHO $path | $GREP ^.:`
24397   new_path="$path"
24398   if test "x$has_colon" = x; then
24399     # Not in mixed or Windows style, start by that.
24400     new_path=`cmd //c echo $path`
24401   fi
24402 
24403 
24404   input_path="$new_path"
24405   # Check if we need to convert this using DOS-style short mode. If the path
24406   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24407   # take no chances and rewrite it.
24408   # Note: m4 eats our [], so we need to use [ and ] instead.
24409   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24410   if test "x$has_forbidden_chars" != x; then
24411     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24412     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24413   fi
24414 
24415 
24416   windows_path="$new_path"
24417   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24418     unix_path=`$CYGPATH -u "$windows_path"`
24419     new_path="$unix_path"
24420   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24421     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24422     new_path="$unix_path"
24423   fi
24424 
24425   if test "x$path" != "x$new_path"; then
24426     BOOT_JDK="$new_path"
24427     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24428 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24429   fi
24430 
24431   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24432   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24433 
24434   else
24435     # We're on a posix platform. Hooray! :)
24436     path="$BOOT_JDK"
24437     has_space=`$ECHO "$path" | $GREP " "`
24438     if test "x$has_space" != x; then
24439       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24440 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24441       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24442     fi
24443 
24444     # Use eval to expand a potential ~
24445     eval path="$path"
24446     if test ! -f "$path" && test ! -d "$path"; then
24447       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24448     fi
24449 
24450     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24451   fi
24452 
24453               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24454 $as_echo_n "checking for Boot JDK... " >&6; }
24455               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24456 $as_echo "$BOOT_JDK" >&6; }
24457               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24458 $as_echo_n "checking Boot JDK version... " >&6; }
24459               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24460               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24461 $as_echo "$BOOT_JDK_VERSION" >&6; }
24462             fi # end check jdk version
24463           fi # end check rt.jar
24464         fi # end check javac
24465       fi # end check java
24466     fi # end check boot jdk found
24467   fi
24468 
24469     done
24470   fi
24471 
24472 
24473     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24474     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24475       # Do we have a bin/java?
24476       if test ! -x "$BOOT_JDK/bin/java"; then
24477         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24478 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24479         BOOT_JDK_FOUND=no
24480       else
24481         # Do we have a bin/javac?
24482         if test ! -x "$BOOT_JDK/bin/javac"; then
24483           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24484 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24485           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24486 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24487           BOOT_JDK_FOUND=no
24488         else
24489           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
24490           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
24491             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
24492 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
24493             BOOT_JDK_FOUND=no
24494           else
24495             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24496             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24497 
24498             # Extra M4 quote needed to protect [] in grep expression.
24499             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24500             if test "x$FOUND_CORRECT_VERSION" = x; then
24501               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24502 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24503               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24504 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24505               BOOT_JDK_FOUND=no
24506             else
24507               # We're done! :-)
24508               BOOT_JDK_FOUND=yes
24509 
24510   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24511 
24512   # Input might be given as Windows format, start by converting to
24513   # unix format.
24514   path="$BOOT_JDK"
24515   new_path=`$CYGPATH -u "$path"`
24516 
24517   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24518   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24519   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24520   # "foo.exe" is OK but "foo" is an error.
24521   #
24522   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24523   # It is also a way to make sure we got the proper file name for the real test later on.
24524   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24525   if test "x$test_shortpath" = x; then
24526     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24527 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24528     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24529   fi
24530 
24531   # Call helper function which possibly converts this using DOS-style short mode.
24532   # If so, the updated path is stored in $new_path.
24533 
24534   input_path="$new_path"
24535   # Check if we need to convert this using DOS-style short mode. If the path
24536   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24537   # take no chances and rewrite it.
24538   # Note: m4 eats our [], so we need to use [ and ] instead.
24539   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24540   if test "x$has_forbidden_chars" != x; then
24541     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24542     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24543     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24544     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24545       # Going to short mode and back again did indeed matter. Since short mode is
24546       # case insensitive, let's make it lowercase to improve readability.
24547       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24548       # Now convert it back to Unix-stile (cygpath)
24549       input_path=`$CYGPATH -u "$shortmode_path"`
24550       new_path="$input_path"
24551     fi
24552   fi
24553 
24554   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24555   if test "x$test_cygdrive_prefix" = x; then
24556     # As a simple fix, exclude /usr/bin since it's not a real path.
24557     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24558       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24559       # a path prefixed by /cygdrive for fixpath to work.
24560       new_path="$CYGWIN_ROOT_PATH$input_path"
24561     fi
24562   fi
24563 
24564 
24565   if test "x$path" != "x$new_path"; then
24566     BOOT_JDK="$new_path"
24567     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24568 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24569   fi
24570 
24571   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24572 
24573   path="$BOOT_JDK"
24574   has_colon=`$ECHO $path | $GREP ^.:`
24575   new_path="$path"
24576   if test "x$has_colon" = x; then
24577     # Not in mixed or Windows style, start by that.
24578     new_path=`cmd //c echo $path`
24579   fi
24580 
24581 
24582   input_path="$new_path"
24583   # Check if we need to convert this using DOS-style short mode. If the path
24584   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24585   # take no chances and rewrite it.
24586   # Note: m4 eats our [], so we need to use [ and ] instead.
24587   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24588   if test "x$has_forbidden_chars" != x; then
24589     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24590     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24591   fi
24592 
24593 
24594   windows_path="$new_path"
24595   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24596     unix_path=`$CYGPATH -u "$windows_path"`
24597     new_path="$unix_path"
24598   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24599     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24600     new_path="$unix_path"
24601   fi
24602 
24603   if test "x$path" != "x$new_path"; then
24604     BOOT_JDK="$new_path"
24605     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24606 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24607   fi
24608 
24609   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24610   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24611 
24612   else
24613     # We're on a posix platform. Hooray! :)
24614     path="$BOOT_JDK"
24615     has_space=`$ECHO "$path" | $GREP " "`
24616     if test "x$has_space" != x; then
24617       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24618 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24619       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24620     fi
24621 
24622     # Use eval to expand a potential ~
24623     eval path="$path"
24624     if test ! -f "$path" && test ! -d "$path"; then
24625       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24626     fi
24627 
24628     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24629   fi
24630 
24631               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24632 $as_echo_n "checking for Boot JDK... " >&6; }
24633               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24634 $as_echo "$BOOT_JDK" >&6; }
24635               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24636 $as_echo_n "checking Boot JDK version... " >&6; }
24637               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24638               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24639 $as_echo "$BOOT_JDK_VERSION" >&6; }
24640             fi # end check jdk version
24641           fi # end check rt.jar
24642         fi # end check javac
24643       fi # end check java
24644     fi # end check boot jdk found
24645   fi
24646 
24647   elif test "x$OPENJDK_TARGET_OS" = xlinux; then
24648 
24649   if test "x$BOOT_JDK_FOUND" = xno; then
24650     # Now execute the test
24651 
24652   BOOT_JDK_PREFIX="/usr/lib/jvm"
24653   BOOT_JDK_SUFFIX=""
24654   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24655   if test "x$ALL_JDKS_FOUND" != x; then
24656     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24657 
24658   if test "x$BOOT_JDK_FOUND" = xno; then
24659     # Now execute the test
24660 
24661         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24662         if test -d "$BOOT_JDK"; then
24663           BOOT_JDK_FOUND=maybe
24664           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24665 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24666         fi
24667 
24668 
24669     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24670     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24671       # Do we have a bin/java?
24672       if test ! -x "$BOOT_JDK/bin/java"; then
24673         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24674 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24675         BOOT_JDK_FOUND=no
24676       else
24677         # Do we have a bin/javac?
24678         if test ! -x "$BOOT_JDK/bin/javac"; then
24679           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24680 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24681           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24682 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24683           BOOT_JDK_FOUND=no
24684         else
24685           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
24686           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
24687             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
24688 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
24689             BOOT_JDK_FOUND=no
24690           else
24691             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24692             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24693 
24694             # Extra M4 quote needed to protect [] in grep expression.
24695             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24696             if test "x$FOUND_CORRECT_VERSION" = x; then
24697               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24698 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24699               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24700 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24701               BOOT_JDK_FOUND=no
24702             else
24703               # We're done! :-)
24704               BOOT_JDK_FOUND=yes
24705 
24706   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24707 
24708   # Input might be given as Windows format, start by converting to
24709   # unix format.
24710   path="$BOOT_JDK"
24711   new_path=`$CYGPATH -u "$path"`
24712 
24713   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24714   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24715   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24716   # "foo.exe" is OK but "foo" is an error.
24717   #
24718   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24719   # It is also a way to make sure we got the proper file name for the real test later on.
24720   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24721   if test "x$test_shortpath" = x; then
24722     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24723 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24724     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24725   fi
24726 
24727   # Call helper function which possibly converts this using DOS-style short mode.
24728   # If so, the updated path is stored in $new_path.
24729 
24730   input_path="$new_path"
24731   # Check if we need to convert this using DOS-style short mode. If the path
24732   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24733   # take no chances and rewrite it.
24734   # Note: m4 eats our [], so we need to use [ and ] instead.
24735   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24736   if test "x$has_forbidden_chars" != x; then
24737     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24738     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24739     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24740     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24741       # Going to short mode and back again did indeed matter. Since short mode is
24742       # case insensitive, let's make it lowercase to improve readability.
24743       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24744       # Now convert it back to Unix-stile (cygpath)
24745       input_path=`$CYGPA