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_LIBGIF
 660 USE_EXTERNAL_LIBJPEG
 661 ALSA_LIBS
 662 ALSA_CFLAGS
 663 FREETYPE_BUNDLE_LIB_PATH
 664 FREETYPE_LIBS
 665 FREETYPE_CFLAGS
 666 CUPS_CFLAGS
 667 OPENWIN_HOME
 668 X_EXTRA_LIBS
 669 X_LIBS
 670 X_PRE_LIBS
 671 X_CFLAGS
 672 XMKMF
 673 FIXPATH
 674 ZIP_DEBUGINFO_FILES
 675 ENABLE_DEBUG_SYMBOLS
 676 CFLAGS_WARNINGS_ARE_ERRORS
 677 COMPILER_SUPPORTS_TARGET_BITS_FLAG
 678 ZERO_ARCHFLAG
 679 LDFLAGS_CXX_JDK
 680 LDFLAGS_JDKEXE_SUFFIX
 681 LDFLAGS_JDKLIB_SUFFIX
 682 LDFLAGS_JDKEXE
 683 LDFLAGS_JDKLIB
 684 CXXFLAGS_JDKEXE
 685 CXXFLAGS_JDKLIB
 686 CFLAGS_JDKEXE
 687 CFLAGS_JDKLIB
 688 MACOSX_VERSION_MIN
 689 LEGACY_EXTRA_LDFLAGS
 690 LEGACY_EXTRA_CXXFLAGS
 691 LEGACY_EXTRA_CFLAGS
 692 CXX_O_FLAG_NONE
 693 CXX_O_FLAG_NORM
 694 CXX_O_FLAG_HI
 695 CXX_O_FLAG_HIGHEST
 696 C_O_FLAG_NONE
 697 C_O_FLAG_NORM
 698 C_O_FLAG_HI
 699 C_O_FLAG_HIGHEST
 700 CXXFLAGS_DEBUG_SYMBOLS
 701 CFLAGS_DEBUG_SYMBOLS
 702 CXX_FLAG_DEPS
 703 C_FLAG_DEPS
 704 SET_SHARED_LIBRARY_MAPFILE
 705 SET_SHARED_LIBRARY_NAME
 706 SET_SHARED_LIBRARY_ORIGIN
 707 SET_EXECUTABLE_ORIGIN
 708 SHARED_LIBRARY_FLAGS
 709 CXX_FLAG_REORDER
 710 C_FLAG_REORDER


 711 RC_FLAGS
 712 AR_OUT_OPTION
 713 LD_OUT_OPTION
 714 EXE_OUT_OPTION
 715 CC_OUT_OPTION
 716 POST_MCS_CMD
 717 POST_STRIP_CMD
 718 ARFLAGS
 719 COMPILER_TARGET_BITS_FLAG
 720 JT_HOME
 721 JTREGEXE
 722 USING_BROKEN_SUSE_LD
 723 PACKAGE_PATH
 724 LDEXECXX
 725 LDEXE
 726 USE_CLANG
 727 HOTSPOT_LD
 728 HOTSPOT_CXX
 729 HOTSPOT_RC
 730 HOTSPOT_MT
 731 BUILD_LD
 732 BUILD_CXX
 733 BUILD_CC
 734 ac_ct_OBJDUMP
 735 OBJDUMP
 736 ac_ct_OBJCOPY
 737 OBJCOPY
 738 ac_ct_NM
 739 ac_ct_STRIP
 740 MCS
 741 GNM
 742 NM
 743 STRIP
 744 DUMPBIN
 745 RC
 746 MT
 747 LIPO
 748 ac_ct_OBJC
 749 OBJCFLAGS
 750 OBJC
 751 ac_ct_AR
 752 AR
 753 AS
 754 LDCXX
 755 LD
 756 CXXCPP
 757 CPP
 758 ac_ct_CXX
 759 CXXFLAGS
 760 CXX
 761 ac_ct_PROPER_COMPILER_CXX
 762 PROPER_COMPILER_CXX
 763 TOOLS_DIR_CXX
 764 POTENTIAL_CXX
 765 OBJEXT
 766 EXEEXT
 767 ac_ct_CC
 768 CPPFLAGS
 769 LDFLAGS
 770 CFLAGS
 771 CC
 772 ac_ct_PROPER_COMPILER_CC
 773 PROPER_COMPILER_CC
 774 TOOLS_DIR_CC
 775 POTENTIAL_CC
 776 VS_PATH
 777 VS_LIB
 778 VS_INCLUDE
 779 CYGWIN_LINK
 780 EXE_SUFFIX
 781 OBJ_SUFFIX
 782 STATIC_LIBRARY
 783 SHARED_LIBRARY
 784 STATIC_LIBRARY_SUFFIX
 785 SHARED_LIBRARY_SUFFIX
 786 LIBRARY_PREFIX
 787 TOOLCHAIN_TYPE
 788 BUILD_HOTSPOT
 789 HOTSPOT_DIST
 790 BUILD_OUTPUT
 791 OVERRIDE_SRC_ROOT
 792 ADD_SRC_ROOT
 793 JDK_TOPDIR
 794 NASHORN_TOPDIR
 795 HOTSPOT_TOPDIR
 796 JAXWS_TOPDIR
 797 JAXP_TOPDIR
 798 CORBA_TOPDIR
 799 LANGTOOLS_TOPDIR
 800 JAVA_FLAGS_SMALL
 801 JAVA_FLAGS_BIG
 802 JAVA_FLAGS
 803 JAVAC_FLAGS
 804 BOOT_JDK_SOURCETARGET
 805 JARSIGNER
 806 NATIVE2ASCII
 807 JAR
 808 JAVAH
 809 JAVAC
 810 JAVA
 811 BOOT_JDK
 812 BOOT_TOOLSJAR
 813 BOOT_RTJAR
 814 JAVA_CHECK
 815 JAVAC_CHECK
 816 COOKED_BUILD_NUMBER
 817 JDK_VERSION
 818 COPYRIGHT_YEAR
 819 MACOSX_BUNDLE_ID_BASE
 820 MACOSX_BUNDLE_NAME_BASE
 821 COMPANY_NAME
 822 JDK_RC_PLATFORM_NAME
 823 PRODUCT_SUFFIX
 824 PRODUCT_NAME
 825 LAUNCHER_NAME
 826 MILESTONE
 827 JDK_BUILD_NUMBER
 828 JDK_UPDATE_VERSION
 829 JDK_MICRO_VERSION
 830 JDK_MINOR_VERSION
 831 JDK_MAJOR_VERSION
 832 USER_RELEASE_SUFFIX
 833 COMPRESS_JARS
 834 RMICONNECTOR_IIOP
 835 UNLIMITED_CRYPTO
 836 CACERTS_FILE
 837 TEST_IN_BUILD
 838 BUILD_HEADLESS
 839 SUPPORT_HEADFUL
 840 SUPPORT_HEADLESS
 841 BDEPS_FTP
 842 BDEPS_UNZIP
 843 OS_VERSION_MICRO
 844 OS_VERSION_MINOR
 845 OS_VERSION_MAJOR
 846 PKG_CONFIG
 847 CODESIGN
 848 XATTR
 849 DSYMUTIL
 850 IS_GNU_TIME
 851 TIME
 852 STAT
 853 HG
 854 READELF
 855 OTOOL
 856 LDD
 857 ZIP
 858 UNZIP
 859 FIND_DELETE
 860 MAKE
 861 CHECK_TOOLSDIR_MAKE
 862 CHECK_TOOLSDIR_GMAKE
 863 CHECK_MAKE
 864 CHECK_GMAKE
 865 PKGHANDLER
 866 OUTPUT_ROOT
 867 CONF_NAME
 868 SPEC
 869 BUILD_VARIANT_RELEASE
 870 DEBUG_CLASSFILES
 871 FASTDEBUG
 872 VARIANT
 873 DEBUG_LEVEL
 874 MACOSX_UNIVERSAL
 875 INCLUDE_SA
 876 JVM_VARIANT_CORE
 877 JVM_VARIANT_ZEROSHARK
 878 JVM_VARIANT_ZERO
 879 JVM_VARIANT_KERNEL
 880 JVM_VARIANT_MINIMAL1
 881 JVM_VARIANT_CLIENT
 882 JVM_VARIANT_SERVER
 883 JVM_VARIANTS
 884 JVM_INTERPRETER
 885 JDK_VARIANT
 886 SET_OPENJDK
 887 BUILD_LOG_WRAPPER
 888 BUILD_LOG_PREVIOUS
 889 BUILD_LOG
 890 SYS_ROOT
 891 TOPDIR
 892 PATH_SEP
 893 ZERO_ARCHDEF
 894 DEFINE_CROSS_COMPILE_ARCH
 895 LP64
 896 OPENJDK_TARGET_OS_EXPORT_DIR
 897 OPENJDK_TARGET_OS_API_DIR
 898 OPENJDK_TARGET_CPU_JLI_CFLAGS
 899 OPENJDK_TARGET_CPU_OSARCH
 900 OPENJDK_TARGET_CPU_ISADIR
 901 OPENJDK_TARGET_CPU_LIBDIR
 902 OPENJDK_TARGET_CPU_LEGACY_LIB
 903 OPENJDK_TARGET_CPU_LEGACY
 904 REQUIRED_OS_VERSION
 905 REQUIRED_OS_NAME
 906 COMPILE_TYPE
 907 OPENJDK_TARGET_CPU_ENDIAN
 908 OPENJDK_TARGET_CPU_BITS
 909 OPENJDK_TARGET_CPU_ARCH
 910 OPENJDK_TARGET_CPU
 911 OPENJDK_TARGET_OS_API
 912 OPENJDK_TARGET_OS
 913 OPENJDK_BUILD_CPU_ENDIAN
 914 OPENJDK_BUILD_CPU_BITS
 915 OPENJDK_BUILD_CPU_ARCH
 916 OPENJDK_BUILD_CPU
 917 OPENJDK_BUILD_OS_API
 918 OPENJDK_BUILD_OS
 919 OPENJDK_BUILD_AUTOCONF_NAME
 920 OPENJDK_TARGET_AUTOCONF_NAME
 921 target_os
 922 target_vendor
 923 target_cpu
 924 target
 925 host_os
 926 host_vendor
 927 host_cpu
 928 host
 929 build_os
 930 build_vendor
 931 build_cpu
 932 build
 933 SETFILE
 934 DF
 935 READLINK
 936 CYGPATH
 937 SED
 938 FGREP
 939 EGREP
 940 GREP
 941 AWK
 942 XARGS
 943 WHICH
 944 WC
 945 UNIQ
 946 UNAME
 947 TR
 948 TOUCH
 949 TEE
 950 TAR
 951 TAIL
 952 SORT
 953 SH
 954 RM
 955 PRINTF
 956 NAWK
 957 MV
 958 MKTEMP
 959 MKDIR
 960 LS
 961 LN
 962 HEAD
 963 FIND
 964 FILE
 965 EXPR
 966 ECHO
 967 DIRNAME
 968 DIFF
 969 DATE
 970 CUT
 971 CPIO
 972 CP
 973 COMM
 974 CMP
 975 CHMOD
 976 CAT
 977 BASH
 978 BASENAME
 979 DATE_WHEN_CONFIGURED
 980 CONFIGURE_COMMAND_LINE
 981 target_alias
 982 host_alias
 983 build_alias
 984 LIBS
 985 ECHO_T
 986 ECHO_N
 987 ECHO_C
 988 DEFS
 989 mandir
 990 localedir
 991 libdir
 992 psdir
 993 pdfdir
 994 dvidir
 995 htmldir
 996 infodir
 997 docdir
 998 oldincludedir
 999 includedir
1000 localstatedir
1001 sharedstatedir
1002 sysconfdir
1003 datadir
1004 datarootdir
1005 libexecdir
1006 sbindir
1007 bindir
1008 program_transform_name
1009 prefix
1010 exec_prefix
1011 PACKAGE_URL
1012 PACKAGE_BUGREPORT
1013 PACKAGE_STRING
1014 PACKAGE_VERSION
1015 PACKAGE_TARNAME
1016 PACKAGE_NAME
1017 PATH_SEPARATOR
1018 SHELL'
1019 ac_subst_files=''
1020 ac_user_opts='
1021 enable_option_checking
1022 with_target_bits

1023 with_sys_root

1024 with_tools_dir
1025 with_devkit

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_conf_name
1034 with_builddeps_conf
1035 with_builddeps_server
1036 with_builddeps_dir
1037 with_builddeps_group
1038 enable_headful
1039 enable_hotspot_test_in_build
1040 with_cacerts_file
1041 enable_unlimited_crypto
1042 enable_rmiconnector_iiop
1043 with_milestone
1044 with_update_version
1045 with_user_release_suffix
1046 with_build_number
1047 with_boot_jdk
1048 with_boot_jdk_jvmargs
1049 with_add_source_root
1050 with_override_source_root
1051 with_adds_and_overrides
1052 with_override_langtools
1053 with_override_corba
1054 with_override_jaxp
1055 with_override_jaxws
1056 with_override_hotspot
1057 with_override_nashorn
1058 with_override_jdk
1059 with_import_hotspot
1060 with_toolchain_type
1061 with_jtreg
1062 with_extra_cflags
1063 with_extra_cxxflags
1064 with_extra_ldflags
1065 enable_debug_symbols
1066 enable_zip_debug_info
1067 enable_macosx_runtime_support
1068 with_x
1069 with_cups
1070 with_cups_include
1071 with_freetype
1072 with_freetype_include
1073 with_freetype_lib
1074 enable_freetype_bundling
1075 with_alsa
1076 with_alsa_include
1077 with_alsa_lib
1078 with_giflib
1079 with_libpng
1080 with_zlib
1081 with_stdc__lib
1082 with_msvcr_dll
1083 with_dxsdk
1084 with_dxsdk_lib
1085 with_dxsdk_include
1086 with_num_cores
1087 with_memory_size
1088 with_jobs
1089 with_sjavac_server_java
1090 enable_sjavac
1091 enable_precompiled_headers
1092 enable_ccache
1093 with_ccache_dir
1094 '
1095       ac_precious_vars='build_alias
1096 host_alias
1097 target_alias
1098 BASENAME
1099 BASH
1100 CAT
1101 CHMOD
1102 CMP
1103 COMM
1104 CP
1105 CPIO
1106 CUT
1107 DATE
1108 DIFF
1109 DIRNAME
1110 ECHO
1111 EXPR
1112 FILE
1113 FIND
1114 HEAD
1115 LN
1116 LS
1117 MKDIR
1118 MKTEMP
1119 MV
1120 NAWK
1121 PRINTF
1122 RM
1123 SH
1124 SORT
1125 TAIL
1126 TAR
1127 TEE
1128 TOUCH
1129 TR
1130 UNAME
1131 UNIQ
1132 WC
1133 WHICH
1134 XARGS
1135 AWK
1136 GREP
1137 EGREP
1138 FGREP
1139 SED
1140 CYGPATH
1141 READLINK
1142 DF
1143 SETFILE
1144 UNZIP
1145 ZIP
1146 LDD
1147 OTOOL
1148 READELF
1149 HG
1150 STAT
1151 TIME
1152 DSYMUTIL
1153 XATTR
1154 CODESIGN
1155 PKG_CONFIG
1156 JAVA
1157 JAVAC
1158 JAVAH
1159 JAR
1160 NATIVE2ASCII
1161 JARSIGNER
1162 CC
1163 CFLAGS
1164 LDFLAGS
1165 LIBS
1166 CPPFLAGS
1167 CXX
1168 CXXFLAGS
1169 CCC
1170 CPP
1171 CXXCPP
1172 AS
1173 AR
1174 OBJC
1175 OBJCFLAGS
1176 LIPO
1177 STRIP
1178 NM
1179 GNM
1180 MCS
1181 OBJCOPY
1182 OBJDUMP
1183 BUILD_CC
1184 BUILD_CXX
1185 BUILD_LD
1186 JTREGEXE
1187 XMKMF
1188 FREETYPE_CFLAGS
1189 FREETYPE_LIBS
1190 ALSA_CFLAGS
1191 ALSA_LIBS
1192 PNG_CFLAGS
1193 PNG_LIBS
1194 LIBFFI_CFLAGS
1195 LIBFFI_LIBS
1196 CCACHE'
1197 
1198 
1199 # Initialize some variables set by options.
1200 ac_init_help=
1201 ac_init_version=false
1202 ac_unrecognized_opts=
1203 ac_unrecognized_sep=
1204 # The variables have the same names as the options, with
1205 # dashes changed to underlines.
1206 cache_file=/dev/null
1207 exec_prefix=NONE
1208 no_create=
1209 no_recursion=
1210 prefix=NONE
1211 program_prefix=NONE
1212 program_suffix=NONE
1213 program_transform_name=s,x,x,
1214 silent=
1215 site=
1216 srcdir=
1217 verbose=
1218 x_includes=NONE
1219 x_libraries=NONE
1220 
1221 # Installation directory options.
1222 # These are left unexpanded so users can "make install exec_prefix=/foo"
1223 # and all the variables that are supposed to be based on exec_prefix
1224 # by default will actually change.
1225 # Use braces instead of parens because sh, perl, etc. also accept them.
1226 # (The list follows the same order as the GNU Coding Standards.)
1227 bindir='${exec_prefix}/bin'
1228 sbindir='${exec_prefix}/sbin'
1229 libexecdir='${exec_prefix}/libexec'
1230 datarootdir='${prefix}/share'
1231 datadir='${datarootdir}'
1232 sysconfdir='${prefix}/etc'
1233 sharedstatedir='${prefix}/com'
1234 localstatedir='${prefix}/var'
1235 includedir='${prefix}/include'
1236 oldincludedir='/usr/include'
1237 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
1238 infodir='${datarootdir}/info'
1239 htmldir='${docdir}'
1240 dvidir='${docdir}'
1241 pdfdir='${docdir}'
1242 psdir='${docdir}'
1243 libdir='${exec_prefix}/lib'
1244 localedir='${datarootdir}/locale'
1245 mandir='${datarootdir}/man'
1246 
1247 ac_prev=
1248 ac_dashdash=
1249 for ac_option
1250 do
1251   # If the previous option needs an argument, assign it.
1252   if test -n "$ac_prev"; then
1253     eval $ac_prev=\$ac_option
1254     ac_prev=
1255     continue
1256   fi
1257 
1258   case $ac_option in
1259   *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
1260   *=)   ac_optarg= ;;
1261   *)    ac_optarg=yes ;;
1262   esac
1263 
1264   # Accept the important Cygnus configure options, so we can diagnose typos.
1265 
1266   case $ac_dashdash$ac_option in
1267   --)
1268     ac_dashdash=yes ;;
1269 
1270   -bindir | --bindir | --bindi | --bind | --bin | --bi)
1271     ac_prev=bindir ;;
1272   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
1273     bindir=$ac_optarg ;;
1274 
1275   -build | --build | --buil | --bui | --bu)
1276     ac_prev=build_alias ;;
1277   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
1278     build_alias=$ac_optarg ;;
1279 
1280   -cache-file | --cache-file | --cache-fil | --cache-fi \
1281   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
1282     ac_prev=cache_file ;;
1283   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
1284   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
1285     cache_file=$ac_optarg ;;
1286 
1287   --config-cache | -C)
1288     cache_file=config.cache ;;
1289 
1290   -datadir | --datadir | --datadi | --datad)
1291     ac_prev=datadir ;;
1292   -datadir=* | --datadir=* | --datadi=* | --datad=*)
1293     datadir=$ac_optarg ;;
1294 
1295   -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
1296   | --dataroo | --dataro | --datar)
1297     ac_prev=datarootdir ;;
1298   -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
1299   | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
1300     datarootdir=$ac_optarg ;;
1301 
1302   -disable-* | --disable-*)
1303     ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
1304     # Reject names that are not valid shell variable names.
1305     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1306       as_fn_error $? "invalid feature name: $ac_useropt"
1307     ac_useropt_orig=$ac_useropt
1308     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1309     case $ac_user_opts in
1310       *"
1311 "enable_$ac_useropt"
1312 "*) ;;
1313       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
1314          ac_unrecognized_sep=', ';;
1315     esac
1316     eval enable_$ac_useropt=no ;;
1317 
1318   -docdir | --docdir | --docdi | --doc | --do)
1319     ac_prev=docdir ;;
1320   -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
1321     docdir=$ac_optarg ;;
1322 
1323   -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
1324     ac_prev=dvidir ;;
1325   -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
1326     dvidir=$ac_optarg ;;
1327 
1328   -enable-* | --enable-*)
1329     ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
1330     # Reject names that are not valid shell variable names.
1331     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1332       as_fn_error $? "invalid feature name: $ac_useropt"
1333     ac_useropt_orig=$ac_useropt
1334     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1335     case $ac_user_opts in
1336       *"
1337 "enable_$ac_useropt"
1338 "*) ;;
1339       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
1340          ac_unrecognized_sep=', ';;
1341     esac
1342     eval enable_$ac_useropt=\$ac_optarg ;;
1343 
1344   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
1345   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
1346   | --exec | --exe | --ex)
1347     ac_prev=exec_prefix ;;
1348   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
1349   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
1350   | --exec=* | --exe=* | --ex=*)
1351     exec_prefix=$ac_optarg ;;
1352 
1353   -gas | --gas | --ga | --g)
1354     # Obsolete; use --with-gas.
1355     with_gas=yes ;;
1356 
1357   -help | --help | --hel | --he | -h)
1358     ac_init_help=long ;;
1359   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
1360     ac_init_help=recursive ;;
1361   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
1362     ac_init_help=short ;;
1363 
1364   -host | --host | --hos | --ho)
1365     ac_prev=host_alias ;;
1366   -host=* | --host=* | --hos=* | --ho=*)
1367     host_alias=$ac_optarg ;;
1368 
1369   -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
1370     ac_prev=htmldir ;;
1371   -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
1372   | --ht=*)
1373     htmldir=$ac_optarg ;;
1374 
1375   -includedir | --includedir | --includedi | --included | --include \
1376   | --includ | --inclu | --incl | --inc)
1377     ac_prev=includedir ;;
1378   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
1379   | --includ=* | --inclu=* | --incl=* | --inc=*)
1380     includedir=$ac_optarg ;;
1381 
1382   -infodir | --infodir | --infodi | --infod | --info | --inf)
1383     ac_prev=infodir ;;
1384   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
1385     infodir=$ac_optarg ;;
1386 
1387   -libdir | --libdir | --libdi | --libd)
1388     ac_prev=libdir ;;
1389   -libdir=* | --libdir=* | --libdi=* | --libd=*)
1390     libdir=$ac_optarg ;;
1391 
1392   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
1393   | --libexe | --libex | --libe)
1394     ac_prev=libexecdir ;;
1395   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
1396   | --libexe=* | --libex=* | --libe=*)
1397     libexecdir=$ac_optarg ;;
1398 
1399   -localedir | --localedir | --localedi | --localed | --locale)
1400     ac_prev=localedir ;;
1401   -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
1402     localedir=$ac_optarg ;;
1403 
1404   -localstatedir | --localstatedir | --localstatedi | --localstated \
1405   | --localstate | --localstat | --localsta | --localst | --locals)
1406     ac_prev=localstatedir ;;
1407   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
1408   | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
1409     localstatedir=$ac_optarg ;;
1410 
1411   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
1412     ac_prev=mandir ;;
1413   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
1414     mandir=$ac_optarg ;;
1415 
1416   -nfp | --nfp | --nf)
1417     # Obsolete; use --without-fp.
1418     with_fp=no ;;
1419 
1420   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
1421   | --no-cr | --no-c | -n)
1422     no_create=yes ;;
1423 
1424   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
1425   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
1426     no_recursion=yes ;;
1427 
1428   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
1429   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
1430   | --oldin | --oldi | --old | --ol | --o)
1431     ac_prev=oldincludedir ;;
1432   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
1433   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
1434   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
1435     oldincludedir=$ac_optarg ;;
1436 
1437   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
1438     ac_prev=prefix ;;
1439   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
1440     prefix=$ac_optarg ;;
1441 
1442   -program-prefix | --program-prefix | --program-prefi | --program-pref \
1443   | --program-pre | --program-pr | --program-p)
1444     ac_prev=program_prefix ;;
1445   -program-prefix=* | --program-prefix=* | --program-prefi=* \
1446   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
1447     program_prefix=$ac_optarg ;;
1448 
1449   -program-suffix | --program-suffix | --program-suffi | --program-suff \
1450   | --program-suf | --program-su | --program-s)
1451     ac_prev=program_suffix ;;
1452   -program-suffix=* | --program-suffix=* | --program-suffi=* \
1453   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
1454     program_suffix=$ac_optarg ;;
1455 
1456   -program-transform-name | --program-transform-name \
1457   | --program-transform-nam | --program-transform-na \
1458   | --program-transform-n | --program-transform- \
1459   | --program-transform | --program-transfor \
1460   | --program-transfo | --program-transf \
1461   | --program-trans | --program-tran \
1462   | --progr-tra | --program-tr | --program-t)
1463     ac_prev=program_transform_name ;;
1464   -program-transform-name=* | --program-transform-name=* \
1465   | --program-transform-nam=* | --program-transform-na=* \
1466   | --program-transform-n=* | --program-transform-=* \
1467   | --program-transform=* | --program-transfor=* \
1468   | --program-transfo=* | --program-transf=* \
1469   | --program-trans=* | --program-tran=* \
1470   | --progr-tra=* | --program-tr=* | --program-t=*)
1471     program_transform_name=$ac_optarg ;;
1472 
1473   -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
1474     ac_prev=pdfdir ;;
1475   -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
1476     pdfdir=$ac_optarg ;;
1477 
1478   -psdir | --psdir | --psdi | --psd | --ps)
1479     ac_prev=psdir ;;
1480   -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
1481     psdir=$ac_optarg ;;
1482 
1483   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1484   | -silent | --silent | --silen | --sile | --sil)
1485     silent=yes ;;
1486 
1487   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
1488     ac_prev=sbindir ;;
1489   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
1490   | --sbi=* | --sb=*)
1491     sbindir=$ac_optarg ;;
1492 
1493   -sharedstatedir | --sharedstatedir | --sharedstatedi \
1494   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
1495   | --sharedst | --shareds | --shared | --share | --shar \
1496   | --sha | --sh)
1497     ac_prev=sharedstatedir ;;
1498   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
1499   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
1500   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
1501   | --sha=* | --sh=*)
1502     sharedstatedir=$ac_optarg ;;
1503 
1504   -site | --site | --sit)
1505     ac_prev=site ;;
1506   -site=* | --site=* | --sit=*)
1507     site=$ac_optarg ;;
1508 
1509   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
1510     ac_prev=srcdir ;;
1511   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
1512     srcdir=$ac_optarg ;;
1513 
1514   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
1515   | --syscon | --sysco | --sysc | --sys | --sy)
1516     ac_prev=sysconfdir ;;
1517   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
1518   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
1519     sysconfdir=$ac_optarg ;;
1520 
1521   -target | --target | --targe | --targ | --tar | --ta | --t)
1522     ac_prev=target_alias ;;
1523   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
1524     target_alias=$ac_optarg ;;
1525 
1526   -v | -verbose | --verbose | --verbos | --verbo | --verb)
1527     verbose=yes ;;
1528 
1529   -version | --version | --versio | --versi | --vers | -V)
1530     ac_init_version=: ;;
1531 
1532   -with-* | --with-*)
1533     ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1534     # Reject names that are not valid shell variable names.
1535     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1536       as_fn_error $? "invalid package name: $ac_useropt"
1537     ac_useropt_orig=$ac_useropt
1538     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1539     case $ac_user_opts in
1540       *"
1541 "with_$ac_useropt"
1542 "*) ;;
1543       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
1544          ac_unrecognized_sep=', ';;
1545     esac
1546     eval with_$ac_useropt=\$ac_optarg ;;
1547 
1548   -without-* | --without-*)
1549     ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1550     # Reject names that are not valid shell variable names.
1551     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1552       as_fn_error $? "invalid package name: $ac_useropt"
1553     ac_useropt_orig=$ac_useropt
1554     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1555     case $ac_user_opts in
1556       *"
1557 "with_$ac_useropt"
1558 "*) ;;
1559       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
1560          ac_unrecognized_sep=', ';;
1561     esac
1562     eval with_$ac_useropt=no ;;
1563 
1564   --x)
1565     # Obsolete; use --with-x.
1566     with_x=yes ;;
1567 
1568   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
1569   | --x-incl | --x-inc | --x-in | --x-i)
1570     ac_prev=x_includes ;;
1571   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
1572   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
1573     x_includes=$ac_optarg ;;
1574 
1575   -x-libraries | --x-libraries | --x-librarie | --x-librari \
1576   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
1577     ac_prev=x_libraries ;;
1578   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
1579   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1580     x_libraries=$ac_optarg ;;
1581 
1582   -*) as_fn_error $? "unrecognized option: \`$ac_option'
1583 Try \`$0 --help' for more information"
1584     ;;
1585 
1586   *=*)
1587     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1588     # Reject names that are not valid shell variable names.
1589     case $ac_envvar in #(
1590       '' | [0-9]* | *[!_$as_cr_alnum]* )
1591       as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1592     esac
1593     eval $ac_envvar=\$ac_optarg
1594     export $ac_envvar ;;
1595 
1596   *)
1597     # FIXME: should be removed in autoconf 3.0.
1598     $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1599     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1600       $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1601     : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1602     ;;
1603 
1604   esac
1605 done
1606 
1607 if test -n "$ac_prev"; then
1608   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1609   as_fn_error $? "missing argument to $ac_option"
1610 fi
1611 
1612 if test -n "$ac_unrecognized_opts"; then
1613   case $enable_option_checking in
1614     no) ;;
1615     fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1616     *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1617   esac
1618 fi
1619 
1620 # Check all directory arguments for consistency.
1621 for ac_var in   exec_prefix prefix bindir sbindir libexecdir datarootdir \
1622                 datadir sysconfdir sharedstatedir localstatedir includedir \
1623                 oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
1624                 libdir localedir mandir
1625 do
1626   eval ac_val=\$$ac_var
1627   # Remove trailing slashes.
1628   case $ac_val in
1629     */ )
1630       ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
1631       eval $ac_var=\$ac_val;;
1632   esac
1633   # Be sure to have absolute directory names.
1634   case $ac_val in
1635     [\\/$]* | ?:[\\/]* )  continue;;
1636     NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1637   esac
1638   as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1639 done
1640 
1641 # There might be people who depend on the old broken behavior: `$host'
1642 # used to hold the argument of --host etc.
1643 # FIXME: To remove some day.
1644 build=$build_alias
1645 host=$host_alias
1646 target=$target_alias
1647 
1648 # FIXME: To remove some day.
1649 if test "x$host_alias" != x; then
1650   if test "x$build_alias" = x; then
1651     cross_compiling=maybe
1652   elif test "x$build_alias" != "x$host_alias"; then
1653     cross_compiling=yes
1654   fi
1655 fi
1656 
1657 ac_tool_prefix=
1658 test -n "$host_alias" && ac_tool_prefix=$host_alias-
1659 
1660 test "$silent" = yes && exec 6>/dev/null
1661 
1662 
1663 ac_pwd=`pwd` && test -n "$ac_pwd" &&
1664 ac_ls_di=`ls -di .` &&
1665 ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1666   as_fn_error $? "working directory cannot be determined"
1667 test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1668   as_fn_error $? "pwd does not report name of working directory"
1669 
1670 
1671 # Find the source files, if location was not specified.
1672 if test -z "$srcdir"; then
1673   ac_srcdir_defaulted=yes
1674   # Try the directory containing this script, then the parent directory.
1675   ac_confdir=`$as_dirname -- "$as_myself" ||
1676 $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1677          X"$as_myself" : 'X\(//\)[^/]' \| \
1678          X"$as_myself" : 'X\(//\)$' \| \
1679          X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
1680 $as_echo X"$as_myself" |
1681     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
1682             s//\1/
1683             q
1684           }
1685           /^X\(\/\/\)[^/].*/{
1686             s//\1/
1687             q
1688           }
1689           /^X\(\/\/\)$/{
1690             s//\1/
1691             q
1692           }
1693           /^X\(\/\).*/{
1694             s//\1/
1695             q
1696           }
1697           s/.*/./; q'`
1698   srcdir=$ac_confdir
1699   if test ! -r "$srcdir/$ac_unique_file"; then
1700     srcdir=..
1701   fi
1702 else
1703   ac_srcdir_defaulted=no
1704 fi
1705 if test ! -r "$srcdir/$ac_unique_file"; then
1706   test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1707   as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1708 fi
1709 ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1710 ac_abs_confdir=`(
1711         cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1712         pwd)`
1713 # When building in place, set srcdir=.
1714 if test "$ac_abs_confdir" = "$ac_pwd"; then
1715   srcdir=.
1716 fi
1717 # Remove unnecessary trailing slashes from srcdir.
1718 # Double slashes in file names in object file debugging info
1719 # mess up M-x gdb in Emacs.
1720 case $srcdir in
1721 */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
1722 esac
1723 for ac_var in $ac_precious_vars; do
1724   eval ac_env_${ac_var}_set=\${${ac_var}+set}
1725   eval ac_env_${ac_var}_value=\$${ac_var}
1726   eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
1727   eval ac_cv_env_${ac_var}_value=\$${ac_var}
1728 done
1729 
1730 #
1731 # Report the --help message.
1732 #
1733 if test "$ac_init_help" = "long"; then
1734   # Omit some internal or obsolete options to make the list less imposing.
1735   # This message is too long to be a string in the A/UX 3.1 sh.
1736   cat <<_ACEOF
1737 \`configure' configures OpenJDK jdk9 to adapt to many kinds of systems.
1738 
1739 Usage: $0 [OPTION]... [VAR=VALUE]...
1740 
1741 To assign environment variables (e.g., CC, CFLAGS...), specify them as
1742 VAR=VALUE.  See below for descriptions of some of the useful variables.
1743 
1744 Defaults for the options are specified in brackets.
1745 
1746 Configuration:
1747   -h, --help              display this help and exit
1748       --help=short        display options specific to this package
1749       --help=recursive    display the short help of all the included packages
1750   -V, --version           display version information and exit
1751   -q, --quiet, --silent   do not print \`checking ...' messages
1752       --cache-file=FILE   cache test results in FILE [disabled]
1753   -C, --config-cache      alias for \`--cache-file=config.cache'
1754   -n, --no-create         do not create output files
1755       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
1756 
1757 Installation directories:
1758   --prefix=PREFIX         install architecture-independent files in PREFIX
1759                           [$ac_default_prefix]
1760   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
1761                           [PREFIX]
1762 
1763 By default, \`make install' will install all the files in
1764 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
1765 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
1766 for instance \`--prefix=\$HOME'.
1767 
1768 For better control, use the options below.
1769 
1770 Fine tuning of the installation directories:
1771   --bindir=DIR            user executables [EPREFIX/bin]
1772   --sbindir=DIR           system admin executables [EPREFIX/sbin]
1773   --libexecdir=DIR        program executables [EPREFIX/libexec]
1774   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
1775   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
1776   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
1777   --libdir=DIR            object code libraries [EPREFIX/lib]
1778   --includedir=DIR        C header files [PREFIX/include]
1779   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
1780   --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
1781   --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
1782   --infodir=DIR           info documentation [DATAROOTDIR/info]
1783   --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
1784   --mandir=DIR            man documentation [DATAROOTDIR/man]
1785   --docdir=DIR            documentation root [DATAROOTDIR/doc/openjdk]
1786   --htmldir=DIR           html documentation [DOCDIR]
1787   --dvidir=DIR            dvi documentation [DOCDIR]
1788   --pdfdir=DIR            pdf documentation [DOCDIR]
1789   --psdir=DIR             ps documentation [DOCDIR]
1790 _ACEOF
1791 
1792   cat <<\_ACEOF
1793 
1794 X features:
1795   --x-includes=DIR    X include files are in DIR
1796   --x-libraries=DIR   X library files are in DIR
1797 
1798 System types:
1799   --build=BUILD     configure for building on BUILD [guessed]
1800   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
1801   --target=TARGET   configure for building compilers for TARGET [HOST]
1802 _ACEOF
1803 fi
1804 
1805 if test -n "$ac_init_help"; then
1806   case $ac_init_help in
1807      short | recursive ) echo "Configuration of OpenJDK jdk9:";;
1808    esac
1809   cat <<\_ACEOF
1810 
1811 Optional Features:
1812   --disable-option-checking  ignore unrecognized --enable/--with options
1813   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1814   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
1815   --enable-openjdk-only   suppress building custom source even if present
1816                           [disabled]
1817   --enable-debug          set the debug level to fastdebug (shorthand for
1818                           --with-debug-level=fastdebug) [disabled]
1819   --disable-headful       disable building headful support (graphical UI
1820                           support) [enabled]
1821   --enable-hotspot-test-in-build
1822                           run the Queens test after Hotspot build [disabled]
1823   --enable-unlimited-crypto
1824                           Enable unlimited crypto policy [disabled]
1825   --enable-rmiconnector-iiop
1826                           enable the JMX RMIConnector iiop transport
1827                           [disabled]
1828   --disable-debug-symbols disable generation of debug symbols [enabled]
1829   --disable-zip-debug-info
1830                           disable zipping of debug-info files [enabled]
1831   --enable-macosx-runtime-support
1832                           Deprecated. Option is kept for backwards
1833                           compatibility and is ignored
1834   --disable-freetype-bundling
1835                           disable bundling of the freetype library with the
1836                           build result [enabled on Windows or when using
1837                           --with-freetype, disabled otherwise]
1838   --enable-sjavac         use sjavac to do fast incremental compiles
1839                           [disabled]
1840   --disable-precompiled-headers
1841                           disable using precompiled headers when compiling C++
1842                           [enabled]
1843   --enable-ccache         enable using ccache to speed up recompilations
1844                           [disabled]
1845 
1846 Optional Packages:
1847   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1848   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
1849   --with-target-bits      build 32-bit or 64-bit binaries (for platforms that
1850                           support it), e.g. --with-target-bits=32 [guessed]
1851   --with-sys-root         pass this sys-root to the compilers and tools (for
1852                           cross-compiling)
1853   --with-tools-dir        search this directory for compilers and tools (for
1854                           cross-compiling)
1855   --with-devkit           use this directory as base for tools-dir and
1856                           sys-root (for cross-compiling)







1857   --with-custom-make-dir  Deprecated. Option is kept for backwards
1858                           compatibility and is ignored
1859   --with-jdk-variant      JDK variant to build (normal) [normal]
1860   --with-jvm-interpreter  JVM interpreter to build (template, cpp) [template]
1861   --with-jvm-variants     JVM variants (separated by commas) to build (server,
1862                           client, minimal1, kernel, zero, zeroshark, core)
1863                           [server]
1864   --with-debug-level      set the debug level (release, fastdebug, slowdebug,
1865                           optimized (HotSpot build only)) [release]
1866   --with-conf-name        use this as the name of the configuration [generated
1867                           from important configuration options]
1868   --with-builddeps-conf   use this configuration file for the builddeps
1869   --with-builddeps-server download and use build dependencies from this server
1870                           url
1871   --with-builddeps-dir    store downloaded build dependencies here
1872                           [/localhome/builddeps]
1873   --with-builddeps-group  chgrp the downloaded build dependencies to this
1874                           group
1875   --with-cacerts-file     specify alternative cacerts file
1876   --with-milestone        Set milestone value for build [internal]
1877   --with-update-version   Set update version value for build [b00]
1878   --with-user-release-suffix
1879                           Add a custom string to the version string if build
1880                           number is not set.[username_builddateb00]
1881   --with-build-number     Set build number value for build [b00]
1882   --with-boot-jdk         path to Boot JDK (used to bootstrap build) [probed]
1883   --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
1884                           invocations of boot JDK, overriding the default
1885                           values, e.g --with-boot-jdk-jvmargs="-Xmx8G
1886                           -enableassertions"
1887   --with-add-source-root  for each and every source directory, look in this
1888                           additional source root for the same directory; if it
1889                           exists and have files in it, include it in the build
1890   --with-override-source-root
1891                           for each and every source directory, look in this
1892                           override source root for the same directory; if it
1893                           exists, use that directory instead and ignore the
1894                           directory in the original source root
1895   --with-adds-and-overrides
1896                           use the subdirs 'adds' and 'overrides' in the
1897                           specified directory as add-source-root and
1898                           override-source-root
1899   --with-override-langtools
1900                           use this langtools dir for the build
1901   --with-override-corba   use this corba dir for the build
1902   --with-override-jaxp    use this jaxp dir for the build
1903   --with-override-jaxws   use this jaxws dir for the build
1904   --with-override-hotspot use this hotspot dir for the build
1905   --with-override-nashorn use this nashorn dir for the build
1906   --with-override-jdk     use this jdk dir for the build
1907   --with-import-hotspot   import hotspot binaries from this jdk image or
1908                           hotspot build dist dir instead of building from
1909                           source
1910   --with-toolchain-type   the toolchain type (or family) to use, use '--help'
1911                           to show possible values [platform dependent]
1912   --with-jtreg            Regression Test Harness [probed]
1913   --with-extra-cflags     extra flags to be used when compiling jdk c-files
1914   --with-extra-cxxflags   extra flags to be used when compiling jdk c++-files
1915   --with-extra-ldflags    extra flags to be used when linking jdk
1916   --with-x                use the X Window System
1917   --with-cups             specify prefix directory for the cups package
1918                           (expecting the headers under PATH/include)
1919   --with-cups-include     specify directory for the cups include files
1920   --with-freetype         specify prefix directory for the freetype package
1921                           (expecting the libraries under PATH/lib and the
1922                           headers under PATH/include)
1923   --with-freetype-include specify directory for the freetype include files
1924   --with-freetype-lib     specify directory for the freetype library
1925   --with-alsa             specify prefix directory for the alsa package
1926                           (expecting the libraries under PATH/lib and the
1927                           headers under PATH/include)
1928   --with-alsa-include     specify directory for the alsa include files
1929   --with-alsa-lib         specify directory for the alsa library
1930   --with-giflib           use giflib from build system or OpenJDK source
1931                           (system, bundled) [bundled]
1932   --with-libpng           use libpng from build system or OpenJDK source
1933                           (system, bundled) [bundled]
1934   --with-zlib             use zlib from build system or OpenJDK source
1935                           (system, bundled) [bundled]
1936   --with-stdc++lib=<static>,<dynamic>,<default>
1937                           force linking of the C++ runtime on Linux to either
1938                           static or dynamic, default is static with dynamic as
1939                           fallback
1940   --with-msvcr-dll        copy this msvcr100.dll into the built JDK (Windows
1941                           only) [probed]
1942   --with-dxsdk            Deprecated. Option is kept for backwards
1943                           compatibility and is ignored
1944   --with-dxsdk-lib        Deprecated. Option is kept for backwards
1945                           compatibility and is ignored
1946   --with-dxsdk-include    Deprecated. Option is kept for backwards
1947                           compatibility and is ignored
1948   --with-num-cores        number of cores in the build system, e.g.
1949                           --with-num-cores=8 [probed]
1950   --with-memory-size      memory (in MB) available in the build system, e.g.
1951                           --with-memory-size=1024 [probed]
1952   --with-jobs             number of parallel jobs to let make run [calculated
1953                           based on cores and memory]
1954   --with-sjavac-server-java
1955                           use this java binary for running the sjavac
1956                           background server [Boot JDK java]
1957   --with-ccache-dir       where to store ccache files [~/.ccache]
1958 
1959 Some influential environment variables:
1960   BASENAME    Override default value for BASENAME
1961   BASH        Override default value for BASH
1962   CAT         Override default value for CAT
1963   CHMOD       Override default value for CHMOD
1964   CMP         Override default value for CMP
1965   COMM        Override default value for COMM
1966   CP          Override default value for CP
1967   CPIO        Override default value for CPIO
1968   CUT         Override default value for CUT
1969   DATE        Override default value for DATE
1970   DIFF        Override default value for DIFF
1971   DIRNAME     Override default value for DIRNAME
1972   ECHO        Override default value for ECHO
1973   EXPR        Override default value for EXPR
1974   FILE        Override default value for FILE
1975   FIND        Override default value for FIND
1976   HEAD        Override default value for HEAD
1977   LN          Override default value for LN
1978   LS          Override default value for LS
1979   MKDIR       Override default value for MKDIR
1980   MKTEMP      Override default value for MKTEMP
1981   MV          Override default value for MV
1982   NAWK        Override default value for NAWK
1983   PRINTF      Override default value for PRINTF
1984   RM          Override default value for RM
1985   SH          Override default value for SH
1986   SORT        Override default value for SORT
1987   TAIL        Override default value for TAIL
1988   TAR         Override default value for TAR
1989   TEE         Override default value for TEE
1990   TOUCH       Override default value for TOUCH
1991   TR          Override default value for TR
1992   UNAME       Override default value for UNAME
1993   UNIQ        Override default value for UNIQ
1994   WC          Override default value for WC
1995   WHICH       Override default value for WHICH
1996   XARGS       Override default value for XARGS
1997   AWK         Override default value for AWK
1998   GREP        Override default value for GREP
1999   EGREP       Override default value for EGREP
2000   FGREP       Override default value for FGREP
2001   SED         Override default value for SED
2002   CYGPATH     Override default value for CYGPATH
2003   READLINK    Override default value for READLINK
2004   DF          Override default value for DF
2005   SETFILE     Override default value for SETFILE
2006   UNZIP       Override default value for UNZIP
2007   ZIP         Override default value for ZIP
2008   LDD         Override default value for LDD
2009   OTOOL       Override default value for OTOOL
2010   READELF     Override default value for READELF
2011   HG          Override default value for HG
2012   STAT        Override default value for STAT
2013   TIME        Override default value for TIME
2014   DSYMUTIL    Override default value for DSYMUTIL
2015   XATTR       Override default value for XATTR
2016   CODESIGN    Override default value for CODESIGN
2017   PKG_CONFIG  path to pkg-config utility
2018   JAVA        Override default value for JAVA
2019   JAVAC       Override default value for JAVAC
2020   JAVAH       Override default value for JAVAH
2021   JAR         Override default value for JAR
2022   NATIVE2ASCII
2023               Override default value for NATIVE2ASCII
2024   JARSIGNER   Override default value for JARSIGNER
2025   CC          C compiler command
2026   CFLAGS      C compiler flags
2027   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
2028               nonstandard directory <lib dir>
2029   LIBS        libraries to pass to the linker, e.g. -l<library>
2030   CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
2031               you have headers in a nonstandard directory <include dir>
2032   CXX         C++ compiler command
2033   CXXFLAGS    C++ compiler flags
2034   CPP         C preprocessor
2035   CXXCPP      C++ preprocessor
2036   AS          Override default value for AS
2037   AR          Override default value for AR
2038   OBJC        Objective C compiler command
2039   OBJCFLAGS   Objective C compiler flags
2040   LIPO        Override default value for LIPO
2041   STRIP       Override default value for STRIP
2042   NM          Override default value for NM
2043   GNM         Override default value for GNM
2044   MCS         Override default value for MCS
2045   OBJCOPY     Override default value for OBJCOPY
2046   OBJDUMP     Override default value for OBJDUMP
2047   BUILD_CC    Override default value for BUILD_CC
2048   BUILD_CXX   Override default value for BUILD_CXX
2049   BUILD_LD    Override default value for BUILD_LD
2050   JTREGEXE    Override default value for JTREGEXE
2051   XMKMF       Path to xmkmf, Makefile generator for X Window System
2052   FREETYPE_CFLAGS
2053               C compiler flags for FREETYPE, overriding pkg-config
2054   FREETYPE_LIBS
2055               linker flags for FREETYPE, overriding pkg-config
2056   ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
2057   ALSA_LIBS   linker flags for ALSA, overriding pkg-config
2058   PNG_CFLAGS  C compiler flags for PNG, overriding pkg-config
2059   PNG_LIBS    linker flags for PNG, overriding pkg-config
2060   LIBFFI_CFLAGS
2061               C compiler flags for LIBFFI, overriding pkg-config
2062   LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
2063   CCACHE      Override default value for CCACHE
2064 
2065 Use these variables to override the choices made by `configure' or to help
2066 it to find libraries and programs with nonstandard names/locations.
2067 
2068 Report bugs to <build-dev@openjdk.java.net>.
2069 OpenJDK home page: <http://openjdk.java.net>.
2070 _ACEOF
2071 ac_status=$?
2072 fi
2073 
2074 if test "$ac_init_help" = "recursive"; then
2075   # If there are subdirs, report their specific --help.
2076   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
2077     test -d "$ac_dir" ||
2078       { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
2079       continue
2080     ac_builddir=.
2081 
2082 case "$ac_dir" in
2083 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
2084 *)
2085   ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
2086   # A ".." for each directory in $ac_dir_suffix.
2087   ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
2088   case $ac_top_builddir_sub in
2089   "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
2090   *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
2091   esac ;;
2092 esac
2093 ac_abs_top_builddir=$ac_pwd
2094 ac_abs_builddir=$ac_pwd$ac_dir_suffix
2095 # for backward compatibility:
2096 ac_top_builddir=$ac_top_build_prefix
2097 
2098 case $srcdir in
2099   .)  # We are building in place.
2100     ac_srcdir=.
2101     ac_top_srcdir=$ac_top_builddir_sub
2102     ac_abs_top_srcdir=$ac_pwd ;;
2103   [\\/]* | ?:[\\/]* )  # Absolute name.
2104     ac_srcdir=$srcdir$ac_dir_suffix;
2105     ac_top_srcdir=$srcdir
2106     ac_abs_top_srcdir=$srcdir ;;
2107   *) # Relative name.
2108     ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
2109     ac_top_srcdir=$ac_top_build_prefix$srcdir
2110     ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
2111 esac
2112 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
2113 
2114     cd "$ac_dir" || { ac_status=$?; continue; }
2115     # Check for guested configure.
2116     if test -f "$ac_srcdir/configure.gnu"; then
2117       echo &&
2118       $SHELL "$ac_srcdir/configure.gnu" --help=recursive
2119     elif test -f "$ac_srcdir/configure"; then
2120       echo &&
2121       $SHELL "$ac_srcdir/configure" --help=recursive
2122     else
2123       $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
2124     fi || ac_status=$?
2125     cd "$ac_pwd" || { ac_status=$?; break; }
2126   done
2127 fi
2128 
2129 test -n "$ac_init_help" && exit $ac_status
2130 if $ac_init_version; then
2131   cat <<\_ACEOF
2132 OpenJDK configure jdk9
2133 generated by GNU Autoconf 2.69
2134 
2135 Copyright (C) 2012 Free Software Foundation, Inc.
2136 This configure script is free software; the Free Software Foundation
2137 gives unlimited permission to copy, distribute and modify it.
2138 _ACEOF
2139   exit
2140 fi
2141 
2142 ## ------------------------ ##
2143 ## Autoconf initialization. ##
2144 ## ------------------------ ##
2145 
2146 # ac_fn_c_try_compile LINENO
2147 # --------------------------
2148 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2149 ac_fn_c_try_compile ()
2150 {
2151   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2152   rm -f conftest.$ac_objext
2153   if { { ac_try="$ac_compile"
2154 case "(($ac_try" in
2155   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2156   *) ac_try_echo=$ac_try;;
2157 esac
2158 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2159 $as_echo "$ac_try_echo"; } >&5
2160   (eval "$ac_compile") 2>conftest.err
2161   ac_status=$?
2162   if test -s conftest.err; then
2163     grep -v '^ *+' conftest.err >conftest.er1
2164     cat conftest.er1 >&5
2165     mv -f conftest.er1 conftest.err
2166   fi
2167   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2168   test $ac_status = 0; } && {
2169          test -z "$ac_c_werror_flag" ||
2170          test ! -s conftest.err
2171        } && test -s conftest.$ac_objext; then :
2172   ac_retval=0
2173 else
2174   $as_echo "$as_me: failed program was:" >&5
2175 sed 's/^/| /' conftest.$ac_ext >&5
2176 
2177         ac_retval=1
2178 fi
2179   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2180   as_fn_set_status $ac_retval
2181 
2182 } # ac_fn_c_try_compile
2183 
2184 # ac_fn_cxx_try_compile LINENO
2185 # ----------------------------
2186 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2187 ac_fn_cxx_try_compile ()
2188 {
2189   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2190   rm -f conftest.$ac_objext
2191   if { { ac_try="$ac_compile"
2192 case "(($ac_try" in
2193   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2194   *) ac_try_echo=$ac_try;;
2195 esac
2196 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2197 $as_echo "$ac_try_echo"; } >&5
2198   (eval "$ac_compile") 2>conftest.err
2199   ac_status=$?
2200   if test -s conftest.err; then
2201     grep -v '^ *+' conftest.err >conftest.er1
2202     cat conftest.er1 >&5
2203     mv -f conftest.er1 conftest.err
2204   fi
2205   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2206   test $ac_status = 0; } && {
2207          test -z "$ac_cxx_werror_flag" ||
2208          test ! -s conftest.err
2209        } && test -s conftest.$ac_objext; then :
2210   ac_retval=0
2211 else
2212   $as_echo "$as_me: failed program was:" >&5
2213 sed 's/^/| /' conftest.$ac_ext >&5
2214 
2215         ac_retval=1
2216 fi
2217   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2218   as_fn_set_status $ac_retval
2219 
2220 } # ac_fn_cxx_try_compile
2221 
2222 # ac_fn_c_try_cpp LINENO
2223 # ----------------------
2224 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2225 ac_fn_c_try_cpp ()
2226 {
2227   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2228   if { { ac_try="$ac_cpp conftest.$ac_ext"
2229 case "(($ac_try" in
2230   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2231   *) ac_try_echo=$ac_try;;
2232 esac
2233 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2234 $as_echo "$ac_try_echo"; } >&5
2235   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2236   ac_status=$?
2237   if test -s conftest.err; then
2238     grep -v '^ *+' conftest.err >conftest.er1
2239     cat conftest.er1 >&5
2240     mv -f conftest.er1 conftest.err
2241   fi
2242   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2243   test $ac_status = 0; } > conftest.i && {
2244          test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
2245          test ! -s conftest.err
2246        }; then :
2247   ac_retval=0
2248 else
2249   $as_echo "$as_me: failed program was:" >&5
2250 sed 's/^/| /' conftest.$ac_ext >&5
2251 
2252     ac_retval=1
2253 fi
2254   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2255   as_fn_set_status $ac_retval
2256 
2257 } # ac_fn_c_try_cpp
2258 
2259 # ac_fn_cxx_try_cpp LINENO
2260 # ------------------------
2261 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2262 ac_fn_cxx_try_cpp ()
2263 {
2264   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2265   if { { ac_try="$ac_cpp conftest.$ac_ext"
2266 case "(($ac_try" in
2267   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2268   *) ac_try_echo=$ac_try;;
2269 esac
2270 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2271 $as_echo "$ac_try_echo"; } >&5
2272   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2273   ac_status=$?
2274   if test -s conftest.err; then
2275     grep -v '^ *+' conftest.err >conftest.er1
2276     cat conftest.er1 >&5
2277     mv -f conftest.er1 conftest.err
2278   fi
2279   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2280   test $ac_status = 0; } > conftest.i && {
2281          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2282          test ! -s conftest.err
2283        }; then :
2284   ac_retval=0
2285 else
2286   $as_echo "$as_me: failed program was:" >&5
2287 sed 's/^/| /' conftest.$ac_ext >&5
2288 
2289     ac_retval=1
2290 fi
2291   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2292   as_fn_set_status $ac_retval
2293 
2294 } # ac_fn_cxx_try_cpp
2295 
2296 # ac_fn_objc_try_compile LINENO
2297 # -----------------------------
2298 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2299 ac_fn_objc_try_compile ()
2300 {
2301   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2302   rm -f conftest.$ac_objext
2303   if { { ac_try="$ac_compile"
2304 case "(($ac_try" in
2305   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2306   *) ac_try_echo=$ac_try;;
2307 esac
2308 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2309 $as_echo "$ac_try_echo"; } >&5
2310   (eval "$ac_compile") 2>conftest.err
2311   ac_status=$?
2312   if test -s conftest.err; then
2313     grep -v '^ *+' conftest.err >conftest.er1
2314     cat conftest.er1 >&5
2315     mv -f conftest.er1 conftest.err
2316   fi
2317   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2318   test $ac_status = 0; } && {
2319          test -z "$ac_objc_werror_flag" ||
2320          test ! -s conftest.err
2321        } && test -s conftest.$ac_objext; then :
2322   ac_retval=0
2323 else
2324   $as_echo "$as_me: failed program was:" >&5
2325 sed 's/^/| /' conftest.$ac_ext >&5
2326 
2327         ac_retval=1
2328 fi
2329   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2330   as_fn_set_status $ac_retval
2331 
2332 } # ac_fn_objc_try_compile
2333 
2334 # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2335 # ---------------------------------------------------------
2336 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2337 # the include files in INCLUDES and setting the cache variable VAR
2338 # accordingly.
2339 ac_fn_cxx_check_header_mongrel ()
2340 {
2341   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2342   if eval \${$3+:} false; then :
2343   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2344 $as_echo_n "checking for $2... " >&6; }
2345 if eval \${$3+:} false; then :
2346   $as_echo_n "(cached) " >&6
2347 fi
2348 eval ac_res=\$$3
2349                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2350 $as_echo "$ac_res" >&6; }
2351 else
2352   # Is the header compilable?
2353 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2354 $as_echo_n "checking $2 usability... " >&6; }
2355 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2356 /* end confdefs.h.  */
2357 $4
2358 #include <$2>
2359 _ACEOF
2360 if ac_fn_cxx_try_compile "$LINENO"; then :
2361   ac_header_compiler=yes
2362 else
2363   ac_header_compiler=no
2364 fi
2365 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2366 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2367 $as_echo "$ac_header_compiler" >&6; }
2368 
2369 # Is the header present?
2370 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2371 $as_echo_n "checking $2 presence... " >&6; }
2372 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2373 /* end confdefs.h.  */
2374 #include <$2>
2375 _ACEOF
2376 if ac_fn_cxx_try_cpp "$LINENO"; then :
2377   ac_header_preproc=yes
2378 else
2379   ac_header_preproc=no
2380 fi
2381 rm -f conftest.err conftest.i conftest.$ac_ext
2382 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2383 $as_echo "$ac_header_preproc" >&6; }
2384 
2385 # So?  What about this header?
2386 case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2387   yes:no: )
2388     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2389 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2390     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2391 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2392     ;;
2393   no:yes:* )
2394     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2395 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2396     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
2397 $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
2398     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2399 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2400     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
2401 $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
2402     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2403 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2404 ( $as_echo "## ----------------------------------------- ##
2405 ## Report this to build-dev@openjdk.java.net ##
2406 ## ----------------------------------------- ##"
2407      ) | sed "s/^/$as_me: WARNING:     /" >&2
2408     ;;
2409 esac
2410   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2411 $as_echo_n "checking for $2... " >&6; }
2412 if eval \${$3+:} false; then :
2413   $as_echo_n "(cached) " >&6
2414 else
2415   eval "$3=\$ac_header_compiler"
2416 fi
2417 eval ac_res=\$$3
2418                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2419 $as_echo "$ac_res" >&6; }
2420 fi
2421   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2422 
2423 } # ac_fn_cxx_check_header_mongrel
2424 
2425 # ac_fn_cxx_try_run LINENO
2426 # ------------------------
2427 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2428 # that executables *can* be run.
2429 ac_fn_cxx_try_run ()
2430 {
2431   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2432   if { { ac_try="$ac_link"
2433 case "(($ac_try" in
2434   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2435   *) ac_try_echo=$ac_try;;
2436 esac
2437 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2438 $as_echo "$ac_try_echo"; } >&5
2439   (eval "$ac_link") 2>&5
2440   ac_status=$?
2441   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2442   test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2443   { { case "(($ac_try" in
2444   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2445   *) ac_try_echo=$ac_try;;
2446 esac
2447 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2448 $as_echo "$ac_try_echo"; } >&5
2449   (eval "$ac_try") 2>&5
2450   ac_status=$?
2451   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2452   test $ac_status = 0; }; }; then :
2453   ac_retval=0
2454 else
2455   $as_echo "$as_me: program exited with status $ac_status" >&5
2456        $as_echo "$as_me: failed program was:" >&5
2457 sed 's/^/| /' conftest.$ac_ext >&5
2458 
2459        ac_retval=$ac_status
2460 fi
2461   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2462   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2463   as_fn_set_status $ac_retval
2464 
2465 } # ac_fn_cxx_try_run
2466 
2467 # ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
2468 # ---------------------------------------------------------
2469 # Tests whether HEADER exists and can be compiled using the include files in
2470 # INCLUDES, setting the cache variable VAR accordingly.
2471 ac_fn_cxx_check_header_compile ()
2472 {
2473   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2474   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2475 $as_echo_n "checking for $2... " >&6; }
2476 if eval \${$3+:} false; then :
2477   $as_echo_n "(cached) " >&6
2478 else
2479   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2480 /* end confdefs.h.  */
2481 $4
2482 #include <$2>
2483 _ACEOF
2484 if ac_fn_cxx_try_compile "$LINENO"; then :
2485   eval "$3=yes"
2486 else
2487   eval "$3=no"
2488 fi
2489 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2490 fi
2491 eval ac_res=\$$3
2492                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2493 $as_echo "$ac_res" >&6; }
2494   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2495 
2496 } # ac_fn_cxx_check_header_compile
2497 
2498 # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
2499 # ----------------------------------------------
2500 # Tries to find the compile-time value of EXPR in a program that includes
2501 # INCLUDES, setting VAR accordingly. Returns whether the value could be
2502 # computed
2503 ac_fn_cxx_compute_int ()
2504 {
2505   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2506   if test "$cross_compiling" = yes; then
2507     # Depending upon the size, compute the lo and hi bounds.
2508 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2509 /* end confdefs.h.  */
2510 $4
2511 int
2512 main ()
2513 {
2514 static int test_array [1 - 2 * !(($2) >= 0)];
2515 test_array [0] = 0;
2516 return test_array [0];
2517 
2518   ;
2519   return 0;
2520 }
2521 _ACEOF
2522 if ac_fn_cxx_try_compile "$LINENO"; then :
2523   ac_lo=0 ac_mid=0
2524   while :; do
2525     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2526 /* end confdefs.h.  */
2527 $4
2528 int
2529 main ()
2530 {
2531 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2532 test_array [0] = 0;
2533 return test_array [0];
2534 
2535   ;
2536   return 0;
2537 }
2538 _ACEOF
2539 if ac_fn_cxx_try_compile "$LINENO"; then :
2540   ac_hi=$ac_mid; break
2541 else
2542   as_fn_arith $ac_mid + 1 && ac_lo=$as_val
2543                         if test $ac_lo -le $ac_mid; then
2544                           ac_lo= ac_hi=
2545                           break
2546                         fi
2547                         as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
2548 fi
2549 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2550   done
2551 else
2552   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2553 /* end confdefs.h.  */
2554 $4
2555 int
2556 main ()
2557 {
2558 static int test_array [1 - 2 * !(($2) < 0)];
2559 test_array [0] = 0;
2560 return test_array [0];
2561 
2562   ;
2563   return 0;
2564 }
2565 _ACEOF
2566 if ac_fn_cxx_try_compile "$LINENO"; then :
2567   ac_hi=-1 ac_mid=-1
2568   while :; do
2569     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2570 /* end confdefs.h.  */
2571 $4
2572 int
2573 main ()
2574 {
2575 static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2576 test_array [0] = 0;
2577 return test_array [0];
2578 
2579   ;
2580   return 0;
2581 }
2582 _ACEOF
2583 if ac_fn_cxx_try_compile "$LINENO"; then :
2584   ac_lo=$ac_mid; break
2585 else
2586   as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2587                         if test $ac_mid -le $ac_hi; then
2588                           ac_lo= ac_hi=
2589                           break
2590                         fi
2591                         as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2592 fi
2593 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2594   done
2595 else
2596   ac_lo= ac_hi=
2597 fi
2598 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2599 fi
2600 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2601 # Binary search between lo and hi bounds.
2602 while test "x$ac_lo" != "x$ac_hi"; do
2603   as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2604   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2605 /* end confdefs.h.  */
2606 $4
2607 int
2608 main ()
2609 {
2610 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2611 test_array [0] = 0;
2612 return test_array [0];
2613 
2614   ;
2615   return 0;
2616 }
2617 _ACEOF
2618 if ac_fn_cxx_try_compile "$LINENO"; then :
2619   ac_hi=$ac_mid
2620 else
2621   as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2622 fi
2623 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2624 done
2625 case $ac_lo in #((
2626 ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2627 '') ac_retval=1 ;;
2628 esac
2629   else
2630     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2631 /* end confdefs.h.  */
2632 $4
2633 static long int longval () { return $2; }
2634 static unsigned long int ulongval () { return $2; }
2635 #include <stdio.h>
2636 #include <stdlib.h>
2637 int
2638 main ()
2639 {
2640 
2641   FILE *f = fopen ("conftest.val", "w");
2642   if (! f)
2643     return 1;
2644   if (($2) < 0)
2645     {
2646       long int i = longval ();
2647       if (i != ($2))
2648         return 1;
2649       fprintf (f, "%ld", i);
2650     }
2651   else
2652     {
2653       unsigned long int i = ulongval ();
2654       if (i != ($2))
2655         return 1;
2656       fprintf (f, "%lu", i);
2657     }
2658   /* Do not output a trailing newline, as this causes \r\n confusion
2659      on some platforms.  */
2660   return ferror (f) || fclose (f) != 0;
2661 
2662   ;
2663   return 0;
2664 }
2665 _ACEOF
2666 if ac_fn_cxx_try_run "$LINENO"; then :
2667   echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2668 else
2669   ac_retval=1
2670 fi
2671 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2672   conftest.$ac_objext conftest.beam conftest.$ac_ext
2673 rm -f conftest.val
2674 
2675   fi
2676   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2677   as_fn_set_status $ac_retval
2678 
2679 } # ac_fn_cxx_compute_int
2680 
2681 # ac_fn_cxx_try_link LINENO
2682 # -------------------------
2683 # Try to link conftest.$ac_ext, and return whether this succeeded.
2684 ac_fn_cxx_try_link ()
2685 {
2686   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2687   rm -f conftest.$ac_objext conftest$ac_exeext
2688   if { { ac_try="$ac_link"
2689 case "(($ac_try" in
2690   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2691   *) ac_try_echo=$ac_try;;
2692 esac
2693 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2694 $as_echo "$ac_try_echo"; } >&5
2695   (eval "$ac_link") 2>conftest.err
2696   ac_status=$?
2697   if test -s conftest.err; then
2698     grep -v '^ *+' conftest.err >conftest.er1
2699     cat conftest.er1 >&5
2700     mv -f conftest.er1 conftest.err
2701   fi
2702   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2703   test $ac_status = 0; } && {
2704          test -z "$ac_cxx_werror_flag" ||
2705          test ! -s conftest.err
2706        } && test -s conftest$ac_exeext && {
2707          test "$cross_compiling" = yes ||
2708          test -x conftest$ac_exeext
2709        }; then :
2710   ac_retval=0
2711 else
2712   $as_echo "$as_me: failed program was:" >&5
2713 sed 's/^/| /' conftest.$ac_ext >&5
2714 
2715         ac_retval=1
2716 fi
2717   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2718   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2719   # interfere with the next link command; also delete a directory that is
2720   # left behind by Apple's compiler.  We do this before executing the actions.
2721   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2722   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2723   as_fn_set_status $ac_retval
2724 
2725 } # ac_fn_cxx_try_link
2726 
2727 # ac_fn_cxx_check_func LINENO FUNC VAR
2728 # ------------------------------------
2729 # Tests whether FUNC exists, setting the cache variable VAR accordingly
2730 ac_fn_cxx_check_func ()
2731 {
2732   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2733   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2734 $as_echo_n "checking for $2... " >&6; }
2735 if eval \${$3+:} false; then :
2736   $as_echo_n "(cached) " >&6
2737 else
2738   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2739 /* end confdefs.h.  */
2740 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
2741    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
2742 #define $2 innocuous_$2
2743 
2744 /* System header to define __stub macros and hopefully few prototypes,
2745     which can conflict with char $2 (); below.
2746     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2747     <limits.h> exists even on freestanding compilers.  */
2748 
2749 #ifdef __STDC__
2750 # include <limits.h>
2751 #else
2752 # include <assert.h>
2753 #endif
2754 
2755 #undef $2
2756 
2757 /* Override any GCC internal prototype to avoid an error.
2758    Use char because int might match the return type of a GCC
2759    builtin and then its argument prototype would still apply.  */
2760 #ifdef __cplusplus
2761 extern "C"
2762 #endif
2763 char $2 ();
2764 /* The GNU C library defines this for functions which it implements
2765     to always fail with ENOSYS.  Some functions are actually named
2766     something starting with __ and the normal name is an alias.  */
2767 #if defined __stub_$2 || defined __stub___$2
2768 choke me
2769 #endif
2770 
2771 int
2772 main ()
2773 {
2774 return $2 ();
2775   ;
2776   return 0;
2777 }
2778 _ACEOF
2779 if ac_fn_cxx_try_link "$LINENO"; then :
2780   eval "$3=yes"
2781 else
2782   eval "$3=no"
2783 fi
2784 rm -f core conftest.err conftest.$ac_objext \
2785     conftest$ac_exeext conftest.$ac_ext
2786 fi
2787 eval ac_res=\$$3
2788                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2789 $as_echo "$ac_res" >&6; }
2790   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2791 
2792 } # ac_fn_cxx_check_func
2793 
2794 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
2795 # -------------------------------------------------------
2796 # Tests whether HEADER exists and can be compiled using the include files in
2797 # INCLUDES, setting the cache variable VAR accordingly.
2798 ac_fn_c_check_header_compile ()
2799 {
2800   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2801   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2802 $as_echo_n "checking for $2... " >&6; }
2803 if eval \${$3+:} false; then :
2804   $as_echo_n "(cached) " >&6
2805 else
2806   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2807 /* end confdefs.h.  */
2808 $4
2809 #include <$2>
2810 _ACEOF
2811 if ac_fn_c_try_compile "$LINENO"; then :
2812   eval "$3=yes"
2813 else
2814   eval "$3=no"
2815 fi
2816 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2817 fi
2818 eval ac_res=\$$3
2819                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2820 $as_echo "$ac_res" >&6; }
2821   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2822 
2823 } # ac_fn_c_check_header_compile
2824 cat >config.log <<_ACEOF
2825 This file contains any messages produced by compilers while
2826 running configure, to aid debugging if configure makes a mistake.
2827 
2828 It was created by OpenJDK $as_me jdk9, which was
2829 generated by GNU Autoconf 2.69.  Invocation command line was
2830 
2831   $ $0 $@
2832 
2833 _ACEOF
2834 exec 5>>config.log
2835 {
2836 cat <<_ASUNAME
2837 ## --------- ##
2838 ## Platform. ##
2839 ## --------- ##
2840 
2841 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
2842 uname -m = `(uname -m) 2>/dev/null || echo unknown`
2843 uname -r = `(uname -r) 2>/dev/null || echo unknown`
2844 uname -s = `(uname -s) 2>/dev/null || echo unknown`
2845 uname -v = `(uname -v) 2>/dev/null || echo unknown`
2846 
2847 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
2848 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
2849 
2850 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
2851 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
2852 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
2853 /usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
2854 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
2855 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
2856 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
2857 
2858 _ASUNAME
2859 
2860 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2861 for as_dir in $PATH
2862 do
2863   IFS=$as_save_IFS
2864   test -z "$as_dir" && as_dir=.
2865     $as_echo "PATH: $as_dir"
2866   done
2867 IFS=$as_save_IFS
2868 
2869 } >&5
2870 
2871 cat >&5 <<_ACEOF
2872 
2873 
2874 ## ----------- ##
2875 ## Core tests. ##
2876 ## ----------- ##
2877 
2878 _ACEOF
2879 
2880 
2881 # Keep a trace of the command line.
2882 # Strip out --no-create and --no-recursion so they do not pile up.
2883 # Strip out --silent because we don't want to record it for future runs.
2884 # Also quote any args containing shell meta-characters.
2885 # Make two passes to allow for proper duplicate-argument suppression.
2886 ac_configure_args=
2887 ac_configure_args0=
2888 ac_configure_args1=
2889 ac_must_keep_next=false
2890 for ac_pass in 1 2
2891 do
2892   for ac_arg
2893   do
2894     case $ac_arg in
2895     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
2896     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
2897     | -silent | --silent | --silen | --sile | --sil)
2898       continue ;;
2899     *\'*)
2900       ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
2901     esac
2902     case $ac_pass in
2903     1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2904     2)
2905       as_fn_append ac_configure_args1 " '$ac_arg'"
2906       if test $ac_must_keep_next = true; then
2907         ac_must_keep_next=false # Got value, back to normal.
2908       else
2909         case $ac_arg in
2910           *=* | --config-cache | -C | -disable-* | --disable-* \
2911           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
2912           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
2913           | -with-* | --with-* | -without-* | --without-* | --x)
2914             case "$ac_configure_args0 " in
2915               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
2916             esac
2917             ;;
2918           -* ) ac_must_keep_next=true ;;
2919         esac
2920       fi
2921       as_fn_append ac_configure_args " '$ac_arg'"
2922       ;;
2923     esac
2924   done
2925 done
2926 { ac_configure_args0=; unset ac_configure_args0;}
2927 { ac_configure_args1=; unset ac_configure_args1;}
2928 
2929 # When interrupted or exit'd, cleanup temporary files, and complete
2930 # config.log.  We remove comments because anyway the quotes in there
2931 # would cause problems or look ugly.
2932 # WARNING: Use '\'' to represent an apostrophe within the trap.
2933 # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
2934 trap 'exit_status=$?
2935   # Save into config.log some information that might help in debugging.
2936   {
2937     echo
2938 
2939     $as_echo "## ---------------- ##
2940 ## Cache variables. ##
2941 ## ---------------- ##"
2942     echo
2943     # The following way of writing the cache mishandles newlines in values,
2944 (
2945   for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
2946     eval ac_val=\$$ac_var
2947     case $ac_val in #(
2948     *${as_nl}*)
2949       case $ac_var in #(
2950       *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
2951 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
2952       esac
2953       case $ac_var in #(
2954       _ | IFS | as_nl) ;; #(
2955       BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
2956       *) { eval $ac_var=; unset $ac_var;} ;;
2957       esac ;;
2958     esac
2959   done
2960   (set) 2>&1 |
2961     case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
2962     *${as_nl}ac_space=\ *)
2963       sed -n \
2964         "s/'\''/'\''\\\\'\'''\''/g;
2965           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
2966       ;; #(
2967     *)
2968       sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
2969       ;;
2970     esac |
2971     sort
2972 )
2973     echo
2974 
2975     $as_echo "## ----------------- ##
2976 ## Output variables. ##
2977 ## ----------------- ##"
2978     echo
2979     for ac_var in $ac_subst_vars
2980     do
2981       eval ac_val=\$$ac_var
2982       case $ac_val in
2983       *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
2984       esac
2985       $as_echo "$ac_var='\''$ac_val'\''"
2986     done | sort
2987     echo
2988 
2989     if test -n "$ac_subst_files"; then
2990       $as_echo "## ------------------- ##
2991 ## File substitutions. ##
2992 ## ------------------- ##"
2993       echo
2994       for ac_var in $ac_subst_files
2995       do
2996         eval ac_val=\$$ac_var
2997         case $ac_val in
2998         *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
2999         esac
3000         $as_echo "$ac_var='\''$ac_val'\''"
3001       done | sort
3002       echo
3003     fi
3004 
3005     if test -s confdefs.h; then
3006       $as_echo "## ----------- ##
3007 ## confdefs.h. ##
3008 ## ----------- ##"
3009       echo
3010       cat confdefs.h
3011       echo
3012     fi
3013     test "$ac_signal" != 0 &&
3014       $as_echo "$as_me: caught signal $ac_signal"
3015     $as_echo "$as_me: exit $exit_status"
3016   } >&5
3017   rm -f core *.core core.conftest.* &&
3018     rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
3019     exit $exit_status
3020 ' 0
3021 for ac_signal in 1 2 13 15; do
3022   trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
3023 done
3024 ac_signal=0
3025 
3026 # confdefs.h avoids OS command line length limits that DEFS can exceed.
3027 rm -f -r conftest* confdefs.h
3028 
3029 $as_echo "/* confdefs.h */" > confdefs.h
3030 
3031 # Predefined preprocessor variables.
3032 
3033 cat >>confdefs.h <<_ACEOF
3034 #define PACKAGE_NAME "$PACKAGE_NAME"
3035 _ACEOF
3036 
3037 cat >>confdefs.h <<_ACEOF
3038 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
3039 _ACEOF
3040 
3041 cat >>confdefs.h <<_ACEOF
3042 #define PACKAGE_VERSION "$PACKAGE_VERSION"
3043 _ACEOF
3044 
3045 cat >>confdefs.h <<_ACEOF
3046 #define PACKAGE_STRING "$PACKAGE_STRING"
3047 _ACEOF
3048 
3049 cat >>confdefs.h <<_ACEOF
3050 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
3051 _ACEOF
3052 
3053 cat >>confdefs.h <<_ACEOF
3054 #define PACKAGE_URL "$PACKAGE_URL"
3055 _ACEOF
3056 
3057 
3058 # Let the site file select an alternate cache file if it wants to.
3059 # Prefer an explicitly selected file to automatically selected ones.
3060 ac_site_file1=NONE
3061 ac_site_file2=NONE
3062 if test -n "$CONFIG_SITE"; then
3063   # We do not want a PATH search for config.site.
3064   case $CONFIG_SITE in #((
3065     -*)  ac_site_file1=./$CONFIG_SITE;;
3066     */*) ac_site_file1=$CONFIG_SITE;;
3067     *)   ac_site_file1=./$CONFIG_SITE;;
3068   esac
3069 elif test "x$prefix" != xNONE; then
3070   ac_site_file1=$prefix/share/config.site
3071   ac_site_file2=$prefix/etc/config.site
3072 else
3073   ac_site_file1=$ac_default_prefix/share/config.site
3074   ac_site_file2=$ac_default_prefix/etc/config.site
3075 fi
3076 for ac_site_file in "$ac_site_file1" "$ac_site_file2"
3077 do
3078   test "x$ac_site_file" = xNONE && continue
3079   if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
3080     { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
3081 $as_echo "$as_me: loading site script $ac_site_file" >&6;}
3082     sed 's/^/| /' "$ac_site_file" >&5
3083     . "$ac_site_file" \
3084       || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3085 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3086 as_fn_error $? "failed to load site script $ac_site_file
3087 See \`config.log' for more details" "$LINENO" 5; }
3088   fi
3089 done
3090 
3091 if test -r "$cache_file"; then
3092   # Some versions of bash will fail to source /dev/null (special files
3093   # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
3094   if test /dev/null != "$cache_file" && test -f "$cache_file"; then
3095     { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
3096 $as_echo "$as_me: loading cache $cache_file" >&6;}
3097     case $cache_file in
3098       [\\/]* | ?:[\\/]* ) . "$cache_file";;
3099       *)                      . "./$cache_file";;
3100     esac
3101   fi
3102 else
3103   { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
3104 $as_echo "$as_me: creating cache $cache_file" >&6;}
3105   >$cache_file
3106 fi
3107 
3108 # Check that the precious variables saved in the cache have kept the same
3109 # value.
3110 ac_cache_corrupted=false
3111 for ac_var in $ac_precious_vars; do
3112   eval ac_old_set=\$ac_cv_env_${ac_var}_set
3113   eval ac_new_set=\$ac_env_${ac_var}_set
3114   eval ac_old_val=\$ac_cv_env_${ac_var}_value
3115   eval ac_new_val=\$ac_env_${ac_var}_value
3116   case $ac_old_set,$ac_new_set in
3117     set,)
3118       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
3119 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
3120       ac_cache_corrupted=: ;;
3121     ,set)
3122       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
3123 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
3124       ac_cache_corrupted=: ;;
3125     ,);;
3126     *)
3127       if test "x$ac_old_val" != "x$ac_new_val"; then
3128         # differences in whitespace do not lead to failure.
3129         ac_old_val_w=`echo x $ac_old_val`
3130         ac_new_val_w=`echo x $ac_new_val`
3131         if test "$ac_old_val_w" != "$ac_new_val_w"; then
3132           { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
3133 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
3134           ac_cache_corrupted=:
3135         else
3136           { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
3137 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
3138           eval $ac_var=\$ac_old_val
3139         fi
3140         { $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
3141 $as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
3142         { $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
3143 $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
3144       fi;;
3145   esac
3146   # Pass precious variables to config.status.
3147   if test "$ac_new_set" = set; then
3148     case $ac_new_val in
3149     *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
3150     *) ac_arg=$ac_var=$ac_new_val ;;
3151     esac
3152     case " $ac_configure_args " in
3153       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
3154       *) as_fn_append ac_configure_args " '$ac_arg'" ;;
3155     esac
3156   fi
3157 done
3158 if $ac_cache_corrupted; then
3159   { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3160 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3161   { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
3162 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
3163   as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
3164 fi
3165 ## -------------------- ##
3166 ## Main body of script. ##
3167 ## -------------------- ##
3168 
3169 ac_ext=c
3170 ac_cpp='$CPP $CPPFLAGS'
3171 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3172 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3173 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3174 
3175 
3176 
3177 ac_aux_dir=
3178 for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
3179   if test -f "$ac_dir/install-sh"; then
3180     ac_aux_dir=$ac_dir
3181     ac_install_sh="$ac_aux_dir/install-sh -c"
3182     break
3183   elif test -f "$ac_dir/install.sh"; then
3184     ac_aux_dir=$ac_dir
3185     ac_install_sh="$ac_aux_dir/install.sh -c"
3186     break
3187   elif test -f "$ac_dir/shtool"; then
3188     ac_aux_dir=$ac_dir
3189     ac_install_sh="$ac_aux_dir/shtool install -c"
3190     break
3191   fi
3192 done
3193 if test -z "$ac_aux_dir"; then
3194   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
3195 fi
3196 
3197 # These three variables are undocumented and unsupported,
3198 # and are intended to be withdrawn in a future Autoconf release.
3199 # They can cause serious problems if a builder's source tree is in a directory
3200 # whose full name contains unusual characters.
3201 ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
3202 ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
3203 ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
3204 
3205 
3206 # pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
3207 
3208 #
3209 # Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3210 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3211 #
3212 # This code is free software; you can redistribute it and/or modify it
3213 # under the terms of the GNU General Public License version 2 only, as
3214 # published by the Free Software Foundation.  Oracle designates this
3215 # particular file as subject to the "Classpath" exception as provided
3216 # by Oracle in the LICENSE file that accompanied this code.
3217 #
3218 # This code is distributed in the hope that it will be useful, but WITHOUT
3219 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3220 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3221 # version 2 for more details (a copy is included in the LICENSE file that
3222 # accompanied this code).
3223 #
3224 # You should have received a copy of the GNU General Public License version
3225 # 2 along with this work; if not, write to the Free Software Foundation,
3226 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3227 #
3228 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3229 # or visit www.oracle.com if you need additional information or have any
3230 # questions.
3231 #
3232 
3233 #
3234 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
3235 #
3236 # This program is free software; you can redistribute it and/or modify
3237 # it under the terms of the GNU General Public License as published by
3238 # the Free Software Foundation; either version 2 of the License, or
3239 # (at your option) any later version.
3240 #
3241 # This program is distributed in the hope that it will be useful, but
3242 # WITHOUT ANY WARRANTY; without even the implied warranty of
3243 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3244 # General Public License for more details.
3245 #
3246 # You should have received a copy of the GNU General Public License
3247 # along with this program; if not, write to the Free Software
3248 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3249 #
3250 # As a special exception to the GNU General Public License, if you
3251 # distribute this file as part of a program that contains a
3252 # configuration script generated by Autoconf, you may include it under
3253 # the same distribution terms that you use for the rest of that program.
3254 
3255 # PKG_PROG_PKG_CONFIG([MIN-VERSION])
3256 # ----------------------------------
3257 # PKG_PROG_PKG_CONFIG
3258 
3259 # PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
3260 #
3261 # Check to see whether a particular set of modules exists.  Similar
3262 # to PKG_CHECK_MODULES(), but does not set variables or print errors.
3263 #
3264 #
3265 # Similar to PKG_CHECK_MODULES, make sure that the first instance of
3266 # this or PKG_CHECK_MODULES is called, or make sure to call
3267 # PKG_CHECK_EXISTS manually
3268 # --------------------------------------------------------------
3269 
3270 
3271 
3272 # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
3273 # ---------------------------------------------
3274 # _PKG_CONFIG
3275 
3276 # _PKG_SHORT_ERRORS_SUPPORTED
3277 # -----------------------------
3278 # _PKG_SHORT_ERRORS_SUPPORTED
3279 
3280 
3281 # PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
3282 # [ACTION-IF-NOT-FOUND])
3283 #
3284 #
3285 # Note that if there is a possibility the first call to
3286 # PKG_CHECK_MODULES might not happen, you should be sure to include an
3287 # explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
3288 #
3289 #
3290 # --------------------------------------------------------------
3291 # PKG_CHECK_MODULES
3292 
3293 
3294 # Include these first...
3295 #
3296 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3297 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3298 #
3299 # This code is free software; you can redistribute it and/or modify it
3300 # under the terms of the GNU General Public License version 2 only, as
3301 # published by the Free Software Foundation.  Oracle designates this
3302 # particular file as subject to the "Classpath" exception as provided
3303 # by Oracle in the LICENSE file that accompanied this code.
3304 #
3305 # This code is distributed in the hope that it will be useful, but WITHOUT
3306 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3307 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3308 # version 2 for more details (a copy is included in the LICENSE file that
3309 # accompanied this code).
3310 #
3311 # You should have received a copy of the GNU General Public License version
3312 # 2 along with this work; if not, write to the Free Software Foundation,
3313 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3314 #
3315 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3316 # or visit www.oracle.com if you need additional information or have any
3317 # questions.
3318 #
3319 
3320 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3321 # If so, then append $1 to $2 \
3322 # Also set JVM_ARG_OK to true/false depending on outcome.
3323 
3324 
3325 # Appends a string to a path variable, only adding the : when needed.
3326 
3327 



3328 # This will make sure the given variable points to a full and proper
3329 # path. This means:
3330 # 1) There will be no spaces in the path. On posix platforms,
3331 #    spaces in the path will result in an error. On Windows,
3332 #    the path will be rewritten using short-style to be space-free.
3333 # 2) The path will be absolute, and it will be in unix-style (on
3334 #     cygwin).
3335 # $1: The name of the variable to fix
3336 
3337 
3338 # This will make sure the given variable points to a executable
3339 # with a full and proper path. This means:
3340 # 1) There will be no spaces in the path. On posix platforms,
3341 #    spaces in the path will result in an error. On Windows,
3342 #    the path will be rewritten using short-style to be space-free.
3343 # 2) The path will be absolute, and it will be in unix-style (on
3344 #     cygwin).
3345 # Any arguments given to the executable is preserved.
3346 # If the input variable does not have a directory specification, then
3347 # it need to be in the PATH.
3348 # $1: The name of the variable to fix
3349 
3350 
3351 
3352 
3353 # Register a --with argument but mark it as deprecated
3354 # $1: The name of the with argument to deprecate, not including --with-
3355 
3356 
3357 # Register a --enable argument but mark it as deprecated
3358 # $1: The name of the with argument to deprecate, not including --enable-
3359 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3360 
3361 
3362 
3363 
3364 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3365 # $1: variable to check
3366 
3367 
3368 # Check that there are no unprocessed overridden variables left.
3369 # If so, they are an incorrect argument and we will exit with an error.
3370 
3371 
3372 # Setup a tool for the given variable. If correctly specified by the user,
3373 # use that value, otherwise search for the tool using the supplied code snippet.
3374 # $1: variable to set
3375 # $2: code snippet to call to look for the tool
3376 
3377 
3378 # Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
3379 # $1: variable to set
3380 # $2: executable name (or list of names) to look for
3381 
3382 
3383 # Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
3384 # $1: variable to set
3385 # $2: executable name (or list of names) to look for
3386 
3387 
3388 # Like BASIC_PATH_PROGS but fails if no tool was found.
3389 # $1: variable to set
3390 # $2: executable name (or list of names) to look for
3391 
3392 
3393 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3394 # $1: variable to set
3395 # $2: autoconf macro to call to look for the special tool
3396 
3397 
3398 # Setup the most fundamental tools that relies on not much else to set up,
3399 # but is used by much of the early bootstrap code.
3400 
3401 
3402 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3403 
3404 
3405 
3406 
3407 
3408 
3409 
3410 #%%% Simple tools %%%
3411 
3412 # Check if we have found a usable version of make
3413 # $1: the path to a potential make binary (or empty)
3414 # $2: the description on how we found this
3415 
3416 
3417 # Goes looking for a usable version of GNU make.
3418 
3419 
3420 
3421 
3422 
3423 
3424 # Check if build directory is on local disk. If not possible to determine,
3425 # we prefer to claim it's local.
3426 # Argument 1: directory to test
3427 # Argument 2: what to do if it is on local disk
3428 # Argument 3: what to do otherwise (remote disk or failure)
3429 
3430 
3431 # Check that source files have basic read permissions set. This might
3432 # not be the case in cygwin in certain conditions.
3433 
3434 
3435 
3436 
3437 #
3438 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3439 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3440 #
3441 # This code is free software; you can redistribute it and/or modify it
3442 # under the terms of the GNU General Public License version 2 only, as
3443 # published by the Free Software Foundation.  Oracle designates this
3444 # particular file as subject to the "Classpath" exception as provided
3445 # by Oracle in the LICENSE file that accompanied this code.
3446 #
3447 # This code is distributed in the hope that it will be useful, but WITHOUT
3448 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3449 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3450 # version 2 for more details (a copy is included in the LICENSE file that
3451 # accompanied this code).
3452 #
3453 # You should have received a copy of the GNU General Public License version
3454 # 2 along with this work; if not, write to the Free Software Foundation,
3455 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3456 #
3457 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3458 # or visit www.oracle.com if you need additional information or have any
3459 # questions.
3460 #
3461 
3462 
3463 
3464 
3465 
3466 # Helper function which possibly converts a path using DOS-style short mode.
3467 # If so, the updated path is stored in $new_path.
3468 # $1: The path to check
3469 
3470 
3471 # Helper function which possibly converts a path using DOS-style short mode.
3472 # If so, the updated path is stored in $new_path.
3473 # $1: The path to check
3474 
3475 
3476 # FIXME: The BASIC_FIXUP_*_CYGWIN/MSYS is most likely too convoluted
3477 # and could probably be heavily simplified. However, all changes in this
3478 # area tend to need lot of testing in different scenarios, and in lack of
3479 # proper unit testing, cleaning this up has not been deemed worth the effort
3480 # at the moment.
3481 
3482 
3483 
3484 
3485 
3486 
3487 
3488 
3489 
3490 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3491 
3492 
3493 
3494 
3495 #
3496 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3497 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3498 #
3499 # This code is free software; you can redistribute it and/or modify it
3500 # under the terms of the GNU General Public License version 2 only, as
3501 # published by the Free Software Foundation.  Oracle designates this
3502 # particular file as subject to the "Classpath" exception as provided
3503 # by Oracle in the LICENSE file that accompanied this code.
3504 #
3505 # This code is distributed in the hope that it will be useful, but WITHOUT
3506 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3507 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3508 # version 2 for more details (a copy is included in the LICENSE file that
3509 # accompanied this code).
3510 #
3511 # You should have received a copy of the GNU General Public License version
3512 # 2 along with this work; if not, write to the Free Software Foundation,
3513 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3514 #
3515 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3516 # or visit www.oracle.com if you need additional information or have any
3517 # questions.
3518 #
3519 
3520 
3521 
3522 
3523 
3524 
3525 
3526 
3527 
3528 
3529 
3530 # ... then the rest
3531 #
3532 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3533 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3534 #
3535 # This code is free software; you can redistribute it and/or modify it
3536 # under the terms of the GNU General Public License version 2 only, as
3537 # published by the Free Software Foundation.  Oracle designates this
3538 # particular file as subject to the "Classpath" exception as provided
3539 # by Oracle in the LICENSE file that accompanied this code.
3540 #
3541 # This code is distributed in the hope that it will be useful, but WITHOUT
3542 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3543 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3544 # version 2 for more details (a copy is included in the LICENSE file that
3545 # accompanied this code).
3546 #
3547 # You should have received a copy of the GNU General Public License version
3548 # 2 along with this work; if not, write to the Free Software Foundation,
3549 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3550 #
3551 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3552 # or visit www.oracle.com if you need additional information or have any
3553 # questions.
3554 #
3555 
3556 ########################################################################
3557 # This file handles detection of the Boot JDK. The Boot JDK detection
3558 # process has been developed as a response to solve a complex real-world
3559 # problem. Initially, it was simple, but it has grown as platform after
3560 # platform, idiosyncracy after idiosyncracy has been supported.
3561 #
3562 # The basic idea is this:
3563 # 1) You need an acceptable *) JDK to use as a Boot JDK
3564 # 2) There are several ways to locate a JDK, that are mostly platform
3565 #    dependent **)
3566 # 3) You can have multiple JDKs installed
3567 # 4) If possible, configure should try to dig out an acceptable JDK
3568 #    automatically, without having to resort to command-line options
3569 #
3570 # *)  acceptable means e.g. JDK7 for building JDK8, a complete JDK (with
3571 #     javac) and not a JRE, etc.
3572 #
3573 # **) On Windows we typically use a well-known path.
3574 #     On MacOSX we typically use the tool java_home.
3575 #     On Linux we typically find javac in the $PATH, and then follow a
3576 #     chain of symlinks that often ends up in a real JDK.
3577 #
3578 # This leads to the code where we check in different ways to locate a
3579 # JDK, and if one is found, check if it is acceptable. If not, we print
3580 # our reasons for rejecting it (useful when debugging non-working
3581 # configure situations) and continue checking the next one.
3582 ########################################################################
3583 
3584 # Execute the check given as argument, and verify the result
3585 # If the Boot JDK was previously found, do nothing
3586 # $1 A command line (typically autoconf macro) to execute
3587 
3588 
3589 # Test: Is bootjdk explicitely set by command line arguments?
3590 
3591 
3592 # Test: Is bootjdk available from builddeps?
3593 
3594 
3595 # Test: Is $JAVA_HOME set?
3596 
3597 
3598 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
3599 
3600 
3601 # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
3602 # $1: Argument to the java_home binary (optional)
3603 
3604 
3605 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
3606 
3607 
3608 # Look for a jdk in the given path. If there are multiple, try to select the newest.
3609 # If found, set BOOT_JDK and BOOT_JDK_FOUND.
3610 # $1 = Path to directory containing jdk installations.
3611 # $2 = String to append to the found JDK directory to get the proper JDK home
3612 
3613 
3614 # Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
3615 # environmental variable as base for where to look.
3616 # $1 Name of an environmal variable, assumed to point to the Program Files directory.
3617 
3618 
3619 # Test: Is there a JDK installed in default, well-known locations?
3620 
3621 
3622 # Check that a command-line tool in the Boot JDK is correct
3623 # $1 = name of variable to assign
3624 # $2 = name of binary
3625 
3626 
3627 ###############################################################################
3628 #
3629 # We need a Boot JDK to bootstrap the build.
3630 #
3631 
3632 
3633 
3634 
3635 
3636 #
3637 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3638 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3639 #
3640 # This code is free software; you can redistribute it and/or modify it
3641 # under the terms of the GNU General Public License version 2 only, as
3642 # published by the Free Software Foundation.  Oracle designates this
3643 # particular file as subject to the "Classpath" exception as provided
3644 # by Oracle in the LICENSE file that accompanied this code.
3645 #
3646 # This code is distributed in the hope that it will be useful, but WITHOUT
3647 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3648 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3649 # version 2 for more details (a copy is included in the LICENSE file that
3650 # accompanied this code).
3651 #
3652 # You should have received a copy of the GNU General Public License version
3653 # 2 along with this work; if not, write to the Free Software Foundation,
3654 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3655 #
3656 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3657 # or visit www.oracle.com if you need additional information or have any
3658 # questions.
3659 #
3660 
3661 
3662 
3663 
3664 
3665 
3666 
3667 
3668 
3669 
3670 
3671 
3672 
3673 
3674 
3675 
3676 
3677 
3678 
3679 
3680 #
3681 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3682 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3683 #
3684 # This code is free software; you can redistribute it and/or modify it
3685 # under the terms of the GNU General Public License version 2 only, as
3686 # published by the Free Software Foundation.  Oracle designates this
3687 # particular file as subject to the "Classpath" exception as provided
3688 # by Oracle in the LICENSE file that accompanied this code.
3689 #
3690 # This code is distributed in the hope that it will be useful, but WITHOUT
3691 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3692 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3693 # version 2 for more details (a copy is included in the LICENSE file that
3694 # accompanied this code).
3695 #
3696 # You should have received a copy of the GNU General Public License version
3697 # 2 along with this work; if not, write to the Free Software Foundation,
3698 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3699 #
3700 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3701 # or visit www.oracle.com if you need additional information or have any
3702 # questions.
3703 #
3704 
3705 
3706 
3707 
3708 
3709 # Documentation on common flags used for solstudio in HIGHEST.
3710 #
3711 # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
3712 #          done with care, there are some assumptions below that need to
3713 #          be understood about the use of pointers, and IEEE behavior.
3714 #
3715 # -fns: Use non-standard floating point mode (not IEEE 754)
3716 # -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)
3717 # -fsingle: Use single precision floating point with 'float'
3718 # -xalias_level=basic: Assume memory references via basic pointer types do not alias
3719 #   (Source with excessing pointer casting and data access with mixed
3720 #    pointer types are not recommended)
3721 # -xbuiltin=%all: Use intrinsic or inline versions for math/std functions
3722 #   (If you expect perfect errno behavior, do not use this)
3723 # -xdepend: Loop data dependency optimizations (need -xO3 or higher)
3724 # -xrestrict: Pointer parameters to functions do not overlap
3725 #   (Similar to -xalias_level=basic usage, but less obvious sometimes.
3726 #    If you pass in multiple pointers to the same data, do not use this)
3727 # -xlibmil: Inline some library routines
3728 #   (If you expect perfect errno behavior, do not use this)
3729 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
3730 #   (If you expect perfect errno behavior, do not use this)
3731 #  Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
3732 
3733     # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
3734     # Bug?
3735     #if test "x$OPENJDK_TARGET_CPU" = xsparc; then
3736     #  CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
3737     #  CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
3738     #fi
3739 
3740 
3741 
3742 
3743 
3744 
3745 # FLAGS_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3746 #                                   [RUN-IF-FALSE])
3747 # ------------------------------------------------------------
3748 # Check that the c and c++ compilers support an argument
3749 
3750 
3751 
3752 
3753 #
3754 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3755 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3756 #
3757 # This code is free software; you can redistribute it and/or modify it
3758 # under the terms of the GNU General Public License version 2 only, as
3759 # published by the Free Software Foundation.  Oracle designates this
3760 # particular file as subject to the "Classpath" exception as provided
3761 # by Oracle in the LICENSE file that accompanied this code.
3762 #
3763 # This code is distributed in the hope that it will be useful, but WITHOUT
3764 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3765 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3766 # version 2 for more details (a copy is included in the LICENSE file that
3767 # accompanied this code).
3768 #
3769 # You should have received a copy of the GNU General Public License version
3770 # 2 along with this work; if not, write to the Free Software Foundation,
3771 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3772 #
3773 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3774 # or visit www.oracle.com if you need additional information or have any
3775 # questions.
3776 #
3777 
3778 
3779 
3780 
3781 
3782 cygwin_help() {
3783   case $1 in
3784     unzip)
3785       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P unzip )"
3786       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3787       ;;
3788     zip)
3789       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P zip )"
3790       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3791       ;;
3792     make)
3793       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P make )"
3794       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3795       ;;
3796     freetype)
3797       if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
3798         HELP_MSG="To install freetype, run:
3799 wget \"http://gnuwin32.sourceforge.net/downlinks/freetype.php\" -O /tmp/freetype-setup.exe
3800 chmod +x /tmp/freetype-setup.exe
3801 /tmp/freetype-setup.exe
3802 Follow GUI prompts, and install to default directory \"C:\Program Files (x86)\GnuWin32\".
3803 After installation, locate lib/libfreetype.dll.a and make a copy with the name freetype.dll."
3804       else
3805         HELP_MSG="You need to build a 64-bit version of freetype.
3806 This is not readily available.
3807 You can find source code and build instructions on
3808 http://www.freetype.org/
3809 If you put the resulting build in \"C:\Program Files\GnuWin32\", it will be found automatically."
3810       fi
3811       ;;
3812   esac
3813 }
3814 
3815 msys_help() {
3816   PKGHANDLER_COMMAND=""
3817 }
3818 
3819 apt_help() {
3820   case $1 in
3821     devkit)
3822       PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;;
3823     openjdk)
3824       PKGHANDLER_COMMAND="sudo apt-get install openjdk-7-jdk" ;;
3825     alsa)
3826       PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;;
3827     cups)
3828       PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;;
3829     freetype)
3830       PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;;
3831     pulse)
3832       PKGHANDLER_COMMAND="sudo apt-get install libpulse-dev" ;;
3833     x11)
3834       PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
3835     ccache)
3836       PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
3837   esac
3838 }
3839 
3840 yum_help() {
3841   case $1 in
3842     devkit)
3843       PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;;
3844     openjdk)
3845       PKGHANDLER_COMMAND="sudo yum install java-1.7.0-openjdk" ;;
3846     alsa)
3847       PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;;
3848     cups)
3849       PKGHANDLER_COMMAND="sudo yum install cups-devel" ;;
3850     freetype)
3851       PKGHANDLER_COMMAND="sudo yum install freetype-devel" ;;
3852     pulse)
3853       PKGHANDLER_COMMAND="sudo yum install pulseaudio-libs-devel" ;;
3854     x11)
3855       PKGHANDLER_COMMAND="sudo yum install libXtst-devel libXt-devel libXrender-devel" ;;
3856     ccache)
3857       PKGHANDLER_COMMAND="sudo yum install ccache" ;;
3858   esac
3859 }
3860 
3861 port_help() {
3862   PKGHANDLER_COMMAND=""
3863 }
3864 
3865 pkgutil_help() {
3866   PKGHANDLER_COMMAND=""
3867 }
3868 
3869 pkgadd_help() {
3870   PKGHANDLER_COMMAND=""
3871 }
3872 
3873 # This function will check if we're called from the "configure" wrapper while
3874 # printing --help. If so, we will print out additional information that can
3875 # only be extracted within the autoconf script, and then exit. This must be
3876 # called at the very beginning in configure.ac.
3877 
3878 
3879 
3880 
3881 #
3882 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3883 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3884 #
3885 # This code is free software; you can redistribute it and/or modify it
3886 # under the terms of the GNU General Public License version 2 only, as
3887 # published by the Free Software Foundation.  Oracle designates this
3888 # particular file as subject to the "Classpath" exception as provided
3889 # by Oracle in the LICENSE file that accompanied this code.
3890 #
3891 # This code is distributed in the hope that it will be useful, but WITHOUT
3892 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3893 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3894 # version 2 for more details (a copy is included in the LICENSE file that
3895 # accompanied this code).
3896 #
3897 # You should have received a copy of the GNU General Public License version
3898 # 2 along with this work; if not, write to the Free Software Foundation,
3899 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3900 #
3901 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3902 # or visit www.oracle.com if you need additional information or have any
3903 # questions.
3904 #
3905 
3906 
3907 
3908 
3909 
3910 
3911 
3912 
3913 
3914 
3915 ###############################################################################
3916 #
3917 # Should we build only OpenJDK even if closed sources are present?
3918 #
3919 
3920 
3921 
3922 
3923 ###############################################################################
3924 #
3925 # Setup version numbers
3926 #
3927 
3928 
3929 
3930 
3931 
3932 
3933 #
3934 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3935 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3936 #
3937 # This code is free software; you can redistribute it and/or modify it
3938 # under the terms of the GNU General Public License version 2 only, as
3939 # published by the Free Software Foundation.  Oracle designates this
3940 # particular file as subject to the "Classpath" exception as provided
3941 # by Oracle in the LICENSE file that accompanied this code.
3942 #
3943 # This code is distributed in the hope that it will be useful, but WITHOUT
3944 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3945 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3946 # version 2 for more details (a copy is included in the LICENSE file that
3947 # accompanied this code).
3948 #
3949 # You should have received a copy of the GNU General Public License version
3950 # 2 along with this work; if not, write to the Free Software Foundation,
3951 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3952 #
3953 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3954 # or visit www.oracle.com if you need additional information or have any
3955 # questions.
3956 #
3957 
3958 
3959 
3960 
3961 
3962 
3963 
3964 
3965 
3966 
3967 
3968 
3969 
3970 
3971 
3972 
3973 
3974 
3975 
3976 #
3977 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3978 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3979 #
3980 # This code is free software; you can redistribute it and/or modify it
3981 # under the terms of the GNU General Public License version 2 only, as
3982 # published by the Free Software Foundation.  Oracle designates this
3983 # particular file as subject to the "Classpath" exception as provided
3984 # by Oracle in the LICENSE file that accompanied this code.
3985 #
3986 # This code is distributed in the hope that it will be useful, but WITHOUT
3987 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3988 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3989 # version 2 for more details (a copy is included in the LICENSE file that
3990 # accompanied this code).
3991 #
3992 # You should have received a copy of the GNU General Public License version
3993 # 2 along with this work; if not, write to the Free Software Foundation,
3994 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3995 #
3996 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3997 # or visit www.oracle.com if you need additional information or have any
3998 # questions.
3999 #
4000 
4001 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4002 # Converts autoconf style CPU name to OpenJDK style, into
4003 # VAR_CPU, VAR_CPU_ARCH, VAR_CPU_BITS and VAR_CPU_ENDIAN.
4004 
4005 
4006 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4007 # Converts autoconf style OS name to OpenJDK style, into
4008 # VAR_OS and VAR_OS_API.
4009 
4010 
4011 # Expects $host_os $host_cpu $build_os and $build_cpu
4012 # and $with_target_bits to have been setup!
4013 #
4014 # Translate the standard triplet(quadruplet) definition
4015 # of the target/build system into OPENJDK_TARGET_OS, OPENJDK_TARGET_CPU,
4016 # OPENJDK_BUILD_OS, etc.
4017 
4018 
4019 # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
4020 # accordingly. Must be done after setting up build and target system, but before
4021 # doing anything else with these values.
4022 
4023 
4024 # Setup the legacy variables, for controlling the old makefiles.
4025 #
4026 
4027 
4028 
4029 
4030 #%%% Build and target systems %%%
4031 
4032 
4033 
4034 
4035 # Support macro for PLATFORM_SETUP_OPENJDK_TARGET_BITS.
4036 # Add -mX to various FLAGS variables.
4037 
4038 
4039 
4040 
4041 
4042 
4043 #
4044 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4045 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4046 #
4047 # This code is free software; you can redistribute it and/or modify it
4048 # under the terms of the GNU General Public License version 2 only, as
4049 # published by the Free Software Foundation.  Oracle designates this
4050 # particular file as subject to the "Classpath" exception as provided
4051 # by Oracle in the LICENSE file that accompanied this code.
4052 #
4053 # This code is distributed in the hope that it will be useful, but WITHOUT
4054 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4055 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4056 # version 2 for more details (a copy is included in the LICENSE file that
4057 # accompanied this code).
4058 #
4059 # You should have received a copy of the GNU General Public License version
4060 # 2 along with this work; if not, write to the Free Software Foundation,
4061 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4062 #
4063 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4064 # or visit www.oracle.com if you need additional information or have any
4065 # questions.
4066 #
4067 
4068 
4069 
4070 
4071 
4072 
4073 
4074 
4075 #
4076 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
4077 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4078 #
4079 # This code is free software; you can redistribute it and/or modify it
4080 # under the terms of the GNU General Public License version 2 only, as
4081 # published by the Free Software Foundation.  Oracle designates this
4082 # particular file as subject to the "Classpath" exception as provided
4083 # by Oracle in the LICENSE file that accompanied this code.
4084 #
4085 # This code is distributed in the hope that it will be useful, but WITHOUT
4086 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4087 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4088 # version 2 for more details (a copy is included in the LICENSE file that
4089 # accompanied this code).
4090 #
4091 # You should have received a copy of the GNU General Public License version
4092 # 2 along with this work; if not, write to the Free Software Foundation,
4093 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4094 #
4095 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4096 # or visit www.oracle.com if you need additional information or have any
4097 # questions.
4098 #
4099 
4100 ########################################################################
4101 # This file is responsible for detecting, verifying and setting up the
4102 # toolchain, i.e. the compiler, linker and related utilities. It will setup
4103 # proper paths to the binaries, but it will not setup any flags.
4104 #
4105 # The binaries used is determined by the toolchain type, which is the family of
4106 # compilers and related tools that are used.
4107 ########################################################################
4108 
4109 
4110 # All valid toolchains, regardless of platform (used by help.m4)
4111 VALID_TOOLCHAINS_all="gcc clang solstudio xlc microsoft"
4112 
4113 # These toolchains are valid on different platforms
4114 VALID_TOOLCHAINS_linux="gcc clang"
4115 VALID_TOOLCHAINS_solaris="solstudio"
4116 VALID_TOOLCHAINS_macosx="gcc clang"
4117 VALID_TOOLCHAINS_aix="xlc"
4118 VALID_TOOLCHAINS_windows="microsoft"
4119 
4120 # Toolchain descriptions
4121 TOOLCHAIN_DESCRIPTION_clang="clang/LLVM"
4122 TOOLCHAIN_DESCRIPTION_gcc="GNU Compiler Collection"
4123 TOOLCHAIN_DESCRIPTION_microsoft="Microsoft Visual Studio"
4124 TOOLCHAIN_DESCRIPTION_solstudio="Oracle Solaris Studio"
4125 TOOLCHAIN_DESCRIPTION_xlc="IBM XL C/C++"
4126 
4127 # Setup a number of variables describing how native output files are
4128 # named on this platform/toolchain.
4129 
4130 
4131 # Determine which toolchain type to use, and make sure it is valid for this
4132 # platform. Setup various information about the selected toolchain.
4133 
4134 
4135 # Before we start detecting the toolchain executables, we might need some
4136 # special setup, e.g. additional paths etc.
4137 
4138 
4139 # Restore path, etc
4140 
4141 
4142 # Check if a compiler is of the toolchain type we expect, and save the version
4143 # information from it. If the compiler does not match the expected type,
4144 # this function will abort using AC_MSG_ERROR. If it matches, the version will
4145 # be stored in CC_VERSION_NUMBER/CXX_VERSION_NUMBER (as a dotted number), and
4146 # the full version string in CC_VERSION_STRING/CXX_VERSION_STRING.
4147 #
4148 # $1 = compiler to test (CC or CXX)
4149 # $2 = human readable name of compiler (C or C++)
4150 
4151 
4152 # Try to locate the given C or C++ compiler in the path, or otherwise.
4153 #
4154 # $1 = compiler to test (CC or CXX)
4155 # $2 = human readable name of compiler (C or C++)
4156 # $3 = list of compiler names to search for
4157 
4158 
4159 # Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
4160 # preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
4161 # archiver (AR). Verify that the compilers are correct according to the
4162 # toolchain type.
4163 
4164 
4165 # Setup additional tools that is considered a part of the toolchain, but not the
4166 # core part. Many of these are highly platform-specific and do not exist,
4167 # and/or are not needed on all platforms.
4168 
4169 
4170 # Setup the build tools (i.e, the compiler and linker used to build programs
4171 # that should be run on the build platform, not the target platform, as a build
4172 # helper). Since the non-cross-compile case uses the normal, target compilers
4173 # for this, we can only do this after these have been setup.
4174 
4175 
4176 # Setup legacy variables that are still needed as alternative ways to refer to
4177 # parts of the toolchain.
4178 
4179 
4180 # Do some additional checks on the detected tools.
4181 
4182 
4183 # Setup the JTReg Regression Test Harness.
4184 
4185 
4186 #
4187 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4188 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4189 #
4190 # This code is free software; you can redistribute it and/or modify it
4191 # under the terms of the GNU General Public License version 2 only, as
4192 # published by the Free Software Foundation.  Oracle designates this
4193 # particular file as subject to the "Classpath" exception as provided
4194 # by Oracle in the LICENSE file that accompanied this code.
4195 #
4196 # This code is distributed in the hope that it will be useful, but WITHOUT
4197 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4198 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4199 # version 2 for more details (a copy is included in the LICENSE file that
4200 # accompanied this code).
4201 #
4202 # You should have received a copy of the GNU General Public License version
4203 # 2 along with this work; if not, write to the Free Software Foundation,
4204 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4205 #
4206 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4207 # or visit www.oracle.com if you need additional information or have any
4208 # questions.
4209 #
4210 
4211 
4212 
4213 
4214 
4215 
4216 
4217 # Check if the VS env variables were setup prior to running configure.
4218 # If not, then find vcvarsall.bat and run it automatically, and integrate
4219 # the set env variables into the spec file.
4220 
4221 
4222 
4223 
4224 
4225 
4226 
4227 
4228 
4229 
4230 # This line needs to be here, verbatim, after all includes and the dummy hook
4231 # definitions. It is replaced with custom functionality when building
4232 # custom sources.
4233 #CUSTOM_AUTOCONF_INCLUDE
4234 
4235 # Do not change or remove the following line, it is needed for consistency checks:
4236 DATE_WHEN_GENERATED=1395652496
4237 
4238 ###############################################################################
4239 #
4240 # Initialization / Boot-strapping
4241 #
4242 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4243 # thus it jumps back and forth, each time gaining something needed later on.
4244 #
4245 ###############################################################################
4246 
4247 # If we are requested to print additional help, do that and then exit.
4248 # This must be the very first call.
4249 
4250   if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4251     $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4252     $PRINTF "Which are valid to use depends on the build platform.\n"
4253     for toolchain in $VALID_TOOLCHAINS_all; do
4254       # Use indirect variable referencing
4255       toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4256       TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
4257       $PRINTF "  %-10s  %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
4258     done
4259 
4260     # And now exit directly
4261     exit 0
4262   fi
4263 
4264 
4265 # Basic initialization that must happen first of all in the normal process.
4266 
4267   # Save the original command line. This is passed to us by the wrapper configure script.
4268 
4269   DATE_WHEN_CONFIGURED=`LANG=C date`
4270 
4271   { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
4272 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
4273   { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
4274 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
4275 
4276 
4277   # Start with tools that do not need have cross compilation support
4278   # and can be expected to be found in the default PATH. These tools are
4279   # used by configure. Nor are these tools expected to be found in the
4280   # devkit from the builddeps server either, since they are
4281   # needed to download the devkit.
4282 
4283   # First are all the simple required tools.
4284 
4285 
4286 
4287   # Publish this variable in the help.
4288 
4289 
4290   if test "x$BASENAME" = x; then
4291     # The variable is not set by user, try to locate tool using the code snippet
4292     for ac_prog in basename
4293 do
4294   # Extract the first word of "$ac_prog", so it can be a program name with args.
4295 set dummy $ac_prog; ac_word=$2
4296 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4297 $as_echo_n "checking for $ac_word... " >&6; }
4298 if ${ac_cv_path_BASENAME+:} false; then :
4299   $as_echo_n "(cached) " >&6
4300 else
4301   case $BASENAME in
4302   [\\/]* | ?:[\\/]*)
4303   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4304   ;;
4305   *)
4306   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4307 for as_dir in $PATH
4308 do
4309   IFS=$as_save_IFS
4310   test -z "$as_dir" && as_dir=.
4311     for ac_exec_ext in '' $ac_executable_extensions; do
4312   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4313     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4314     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4315     break 2
4316   fi
4317 done
4318   done
4319 IFS=$as_save_IFS
4320 
4321   ;;
4322 esac
4323 fi
4324 BASENAME=$ac_cv_path_BASENAME
4325 if test -n "$BASENAME"; then
4326   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4327 $as_echo "$BASENAME" >&6; }
4328 else
4329   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4330 $as_echo "no" >&6; }
4331 fi
4332 
4333 
4334   test -n "$BASENAME" && break
4335 done
4336 
4337   else
4338     # The variable is set, but is it from the command line or the environment?
4339 
4340     # Try to remove the string !BASENAME! from our list.
4341     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
4342     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4343       # If it failed, the variable was not from the command line. Ignore it,
4344       # but warn the user (except for BASH, which is always set by the calling BASH).
4345       if test "xBASENAME" != xBASH; then
4346         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
4347 $as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
4348       fi
4349       # Try to locate tool using the code snippet
4350       for ac_prog in basename
4351 do
4352   # Extract the first word of "$ac_prog", so it can be a program name with args.
4353 set dummy $ac_prog; ac_word=$2
4354 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4355 $as_echo_n "checking for $ac_word... " >&6; }
4356 if ${ac_cv_path_BASENAME+:} false; then :
4357   $as_echo_n "(cached) " >&6
4358 else
4359   case $BASENAME in
4360   [\\/]* | ?:[\\/]*)
4361   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4362   ;;
4363   *)
4364   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4365 for as_dir in $PATH
4366 do
4367   IFS=$as_save_IFS
4368   test -z "$as_dir" && as_dir=.
4369     for ac_exec_ext in '' $ac_executable_extensions; do
4370   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4371     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4372     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4373     break 2
4374   fi
4375 done
4376   done
4377 IFS=$as_save_IFS
4378 
4379   ;;
4380 esac
4381 fi
4382 BASENAME=$ac_cv_path_BASENAME
4383 if test -n "$BASENAME"; then
4384   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4385 $as_echo "$BASENAME" >&6; }
4386 else
4387   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4388 $as_echo "no" >&6; }
4389 fi
4390 
4391 
4392   test -n "$BASENAME" && break
4393 done
4394 
4395     else
4396       # If it succeeded, then it was overridden by the user. We will use it
4397       # for the tool.
4398 
4399       # First remove it from the list of overridden variables, so we can test
4400       # for unknown variables in the end.
4401       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4402 
4403       # Check if the provided tool contains a complete path.
4404       tool_specified="$BASENAME"
4405       tool_basename="${tool_specified##*/}"
4406       if test "x$tool_basename" = "x$tool_specified"; then
4407         # A command without a complete path is provided, search $PATH.
4408         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
4409 $as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
4410         # Extract the first word of "$tool_basename", so it can be a program name with args.
4411 set dummy $tool_basename; ac_word=$2
4412 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4413 $as_echo_n "checking for $ac_word... " >&6; }
4414 if ${ac_cv_path_BASENAME+:} false; then :
4415   $as_echo_n "(cached) " >&6
4416 else
4417   case $BASENAME in
4418   [\\/]* | ?:[\\/]*)
4419   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4420   ;;
4421   *)
4422   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4423 for as_dir in $PATH
4424 do
4425   IFS=$as_save_IFS
4426   test -z "$as_dir" && as_dir=.
4427     for ac_exec_ext in '' $ac_executable_extensions; do
4428   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4429     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4430     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4431     break 2
4432   fi
4433 done
4434   done
4435 IFS=$as_save_IFS
4436 
4437   ;;
4438 esac
4439 fi
4440 BASENAME=$ac_cv_path_BASENAME
4441 if test -n "$BASENAME"; then
4442   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4443 $as_echo "$BASENAME" >&6; }
4444 else
4445   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4446 $as_echo "no" >&6; }
4447 fi
4448 
4449 
4450         if test "x$BASENAME" = x; then
4451           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4452         fi
4453       else
4454         # Otherwise we believe it is a complete path. Use it as it is.
4455         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
4456 $as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
4457         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
4458 $as_echo_n "checking for BASENAME... " >&6; }
4459         if test ! -x "$tool_specified"; then
4460           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4461 $as_echo "not found" >&6; }
4462           as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
4463         fi
4464         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4465 $as_echo "$tool_specified" >&6; }
4466       fi
4467     fi
4468   fi
4469 
4470 
4471 
4472   if test "x$BASENAME" = x; then
4473     as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
4474   fi
4475 
4476 
4477 
4478 
4479 
4480   # Publish this variable in the help.
4481 
4482 
4483   if test "x$BASH" = x; then
4484     # The variable is not set by user, try to locate tool using the code snippet
4485     for ac_prog in bash
4486 do
4487   # Extract the first word of "$ac_prog", so it can be a program name with args.
4488 set dummy $ac_prog; ac_word=$2
4489 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4490 $as_echo_n "checking for $ac_word... " >&6; }
4491 if ${ac_cv_path_BASH+:} false; then :
4492   $as_echo_n "(cached) " >&6
4493 else
4494   case $BASH in
4495   [\\/]* | ?:[\\/]*)
4496   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4497   ;;
4498   *)
4499   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4500 for as_dir in $PATH
4501 do
4502   IFS=$as_save_IFS
4503   test -z "$as_dir" && as_dir=.
4504     for ac_exec_ext in '' $ac_executable_extensions; do
4505   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4506     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4507     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4508     break 2
4509   fi
4510 done
4511   done
4512 IFS=$as_save_IFS
4513 
4514   ;;
4515 esac
4516 fi
4517 BASH=$ac_cv_path_BASH
4518 if test -n "$BASH"; then
4519   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4520 $as_echo "$BASH" >&6; }
4521 else
4522   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4523 $as_echo "no" >&6; }
4524 fi
4525 
4526 
4527   test -n "$BASH" && break
4528 done
4529 
4530   else
4531     # The variable is set, but is it from the command line or the environment?
4532 
4533     # Try to remove the string !BASH! from our list.
4534     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
4535     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4536       # If it failed, the variable was not from the command line. Ignore it,
4537       # but warn the user (except for BASH, which is always set by the calling BASH).
4538       if test "xBASH" != xBASH; then
4539         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
4540 $as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
4541       fi
4542       # Try to locate tool using the code snippet
4543       for ac_prog in bash
4544 do
4545   # Extract the first word of "$ac_prog", so it can be a program name with args.
4546 set dummy $ac_prog; ac_word=$2
4547 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4548 $as_echo_n "checking for $ac_word... " >&6; }
4549 if ${ac_cv_path_BASH+:} false; then :
4550   $as_echo_n "(cached) " >&6
4551 else
4552   case $BASH in
4553   [\\/]* | ?:[\\/]*)
4554   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4555   ;;
4556   *)
4557   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4558 for as_dir in $PATH
4559 do
4560   IFS=$as_save_IFS
4561   test -z "$as_dir" && as_dir=.
4562     for ac_exec_ext in '' $ac_executable_extensions; do
4563   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4564     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4565     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4566     break 2
4567   fi
4568 done
4569   done
4570 IFS=$as_save_IFS
4571 
4572   ;;
4573 esac
4574 fi
4575 BASH=$ac_cv_path_BASH
4576 if test -n "$BASH"; then
4577   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4578 $as_echo "$BASH" >&6; }
4579 else
4580   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4581 $as_echo "no" >&6; }
4582 fi
4583 
4584 
4585   test -n "$BASH" && break
4586 done
4587 
4588     else
4589       # If it succeeded, then it was overridden by the user. We will use it
4590       # for the tool.
4591 
4592       # First remove it from the list of overridden variables, so we can test
4593       # for unknown variables in the end.
4594       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4595 
4596       # Check if the provided tool contains a complete path.
4597       tool_specified="$BASH"
4598       tool_basename="${tool_specified##*/}"
4599       if test "x$tool_basename" = "x$tool_specified"; then
4600         # A command without a complete path is provided, search $PATH.
4601         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
4602 $as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
4603         # Extract the first word of "$tool_basename", so it can be a program name with args.
4604 set dummy $tool_basename; ac_word=$2
4605 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4606 $as_echo_n "checking for $ac_word... " >&6; }
4607 if ${ac_cv_path_BASH+:} false; then :
4608   $as_echo_n "(cached) " >&6
4609 else
4610   case $BASH in
4611   [\\/]* | ?:[\\/]*)
4612   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4613   ;;
4614   *)
4615   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4616 for as_dir in $PATH
4617 do
4618   IFS=$as_save_IFS
4619   test -z "$as_dir" && as_dir=.
4620     for ac_exec_ext in '' $ac_executable_extensions; do
4621   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4622     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4623     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4624     break 2
4625   fi
4626 done
4627   done
4628 IFS=$as_save_IFS
4629 
4630   ;;
4631 esac
4632 fi
4633 BASH=$ac_cv_path_BASH
4634 if test -n "$BASH"; then
4635   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4636 $as_echo "$BASH" >&6; }
4637 else
4638   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4639 $as_echo "no" >&6; }
4640 fi
4641 
4642 
4643         if test "x$BASH" = x; then
4644           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4645         fi
4646       else
4647         # Otherwise we believe it is a complete path. Use it as it is.
4648         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
4649 $as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
4650         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
4651 $as_echo_n "checking for BASH... " >&6; }
4652         if test ! -x "$tool_specified"; then
4653           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4654 $as_echo "not found" >&6; }
4655           as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
4656         fi
4657         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4658 $as_echo "$tool_specified" >&6; }
4659       fi
4660     fi
4661   fi
4662 
4663 
4664 
4665   if test "x$BASH" = x; then
4666     as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
4667   fi
4668 
4669 
4670 
4671 
4672 
4673   # Publish this variable in the help.
4674 
4675 
4676   if test "x$CAT" = x; then
4677     # The variable is not set by user, try to locate tool using the code snippet
4678     for ac_prog in cat
4679 do
4680   # Extract the first word of "$ac_prog", so it can be a program name with args.
4681 set dummy $ac_prog; ac_word=$2
4682 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4683 $as_echo_n "checking for $ac_word... " >&6; }
4684 if ${ac_cv_path_CAT+:} false; then :
4685   $as_echo_n "(cached) " >&6
4686 else
4687   case $CAT in
4688   [\\/]* | ?:[\\/]*)
4689   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4690   ;;
4691   *)
4692   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4693 for as_dir in $PATH
4694 do
4695   IFS=$as_save_IFS
4696   test -z "$as_dir" && as_dir=.
4697     for ac_exec_ext in '' $ac_executable_extensions; do
4698   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4699     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4700     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4701     break 2
4702   fi
4703 done
4704   done
4705 IFS=$as_save_IFS
4706 
4707   ;;
4708 esac
4709 fi
4710 CAT=$ac_cv_path_CAT
4711 if test -n "$CAT"; then
4712   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4713 $as_echo "$CAT" >&6; }
4714 else
4715   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4716 $as_echo "no" >&6; }
4717 fi
4718 
4719 
4720   test -n "$CAT" && break
4721 done
4722 
4723   else
4724     # The variable is set, but is it from the command line or the environment?
4725 
4726     # Try to remove the string !CAT! from our list.
4727     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
4728     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4729       # If it failed, the variable was not from the command line. Ignore it,
4730       # but warn the user (except for BASH, which is always set by the calling BASH).
4731       if test "xCAT" != xBASH; then
4732         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
4733 $as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
4734       fi
4735       # Try to locate tool using the code snippet
4736       for ac_prog in cat
4737 do
4738   # Extract the first word of "$ac_prog", so it can be a program name with args.
4739 set dummy $ac_prog; ac_word=$2
4740 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4741 $as_echo_n "checking for $ac_word... " >&6; }
4742 if ${ac_cv_path_CAT+:} false; then :
4743   $as_echo_n "(cached) " >&6
4744 else
4745   case $CAT in
4746   [\\/]* | ?:[\\/]*)
4747   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4748   ;;
4749   *)
4750   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4751 for as_dir in $PATH
4752 do
4753   IFS=$as_save_IFS
4754   test -z "$as_dir" && as_dir=.
4755     for ac_exec_ext in '' $ac_executable_extensions; do
4756   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4757     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4758     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4759     break 2
4760   fi
4761 done
4762   done
4763 IFS=$as_save_IFS
4764 
4765   ;;
4766 esac
4767 fi
4768 CAT=$ac_cv_path_CAT
4769 if test -n "$CAT"; then
4770   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4771 $as_echo "$CAT" >&6; }
4772 else
4773   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4774 $as_echo "no" >&6; }
4775 fi
4776 
4777 
4778   test -n "$CAT" && break
4779 done
4780 
4781     else
4782       # If it succeeded, then it was overridden by the user. We will use it
4783       # for the tool.
4784 
4785       # First remove it from the list of overridden variables, so we can test
4786       # for unknown variables in the end.
4787       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4788 
4789       # Check if the provided tool contains a complete path.
4790       tool_specified="$CAT"
4791       tool_basename="${tool_specified##*/}"
4792       if test "x$tool_basename" = "x$tool_specified"; then
4793         # A command without a complete path is provided, search $PATH.
4794         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
4795 $as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
4796         # Extract the first word of "$tool_basename", so it can be a program name with args.
4797 set dummy $tool_basename; ac_word=$2
4798 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4799 $as_echo_n "checking for $ac_word... " >&6; }
4800 if ${ac_cv_path_CAT+:} false; then :
4801   $as_echo_n "(cached) " >&6
4802 else
4803   case $CAT in
4804   [\\/]* | ?:[\\/]*)
4805   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4806   ;;
4807   *)
4808   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4809 for as_dir in $PATH
4810 do
4811   IFS=$as_save_IFS
4812   test -z "$as_dir" && as_dir=.
4813     for ac_exec_ext in '' $ac_executable_extensions; do
4814   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4815     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4816     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4817     break 2
4818   fi
4819 done
4820   done
4821 IFS=$as_save_IFS
4822 
4823   ;;
4824 esac
4825 fi
4826 CAT=$ac_cv_path_CAT
4827 if test -n "$CAT"; then
4828   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4829 $as_echo "$CAT" >&6; }
4830 else
4831   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4832 $as_echo "no" >&6; }
4833 fi
4834 
4835 
4836         if test "x$CAT" = x; then
4837           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4838         fi
4839       else
4840         # Otherwise we believe it is a complete path. Use it as it is.
4841         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
4842 $as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
4843         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
4844 $as_echo_n "checking for CAT... " >&6; }
4845         if test ! -x "$tool_specified"; then
4846           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4847 $as_echo "not found" >&6; }
4848           as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
4849         fi
4850         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4851 $as_echo "$tool_specified" >&6; }
4852       fi
4853     fi
4854   fi
4855 
4856 
4857 
4858   if test "x$CAT" = x; then
4859     as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
4860   fi
4861 
4862 
4863 
4864 
4865 
4866   # Publish this variable in the help.
4867 
4868 
4869   if test "x$CHMOD" = x; then
4870     # The variable is not set by user, try to locate tool using the code snippet
4871     for ac_prog in chmod
4872 do
4873   # Extract the first word of "$ac_prog", so it can be a program name with args.
4874 set dummy $ac_prog; ac_word=$2
4875 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4876 $as_echo_n "checking for $ac_word... " >&6; }
4877 if ${ac_cv_path_CHMOD+:} false; then :
4878   $as_echo_n "(cached) " >&6
4879 else
4880   case $CHMOD in
4881   [\\/]* | ?:[\\/]*)
4882   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
4883   ;;
4884   *)
4885   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4886 for as_dir in $PATH
4887 do
4888   IFS=$as_save_IFS
4889   test -z "$as_dir" && as_dir=.
4890     for ac_exec_ext in '' $ac_executable_extensions; do
4891   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4892     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
4893     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4894     break 2
4895   fi
4896 done
4897   done
4898 IFS=$as_save_IFS
4899 
4900   ;;
4901 esac
4902 fi
4903 CHMOD=$ac_cv_path_CHMOD
4904 if test -n "$CHMOD"; then
4905   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
4906 $as_echo "$CHMOD" >&6; }
4907 else
4908   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4909 $as_echo "no" >&6; }
4910 fi
4911 
4912 
4913   test -n "$CHMOD" && break
4914 done
4915 
4916   else
4917     # The variable is set, but is it from the command line or the environment?
4918 
4919     # Try to remove the string !CHMOD! from our list.
4920     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
4921     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4922       # If it failed, the variable was not from the command line. Ignore it,
4923       # but warn the user (except for BASH, which is always set by the calling BASH).
4924       if test "xCHMOD" != xBASH; then
4925         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
4926 $as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
4927       fi
4928       # Try to locate tool using the code snippet
4929       for ac_prog in chmod
4930 do
4931   # Extract the first word of "$ac_prog", so it can be a program name with args.
4932 set dummy $ac_prog; ac_word=$2
4933 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4934 $as_echo_n "checking for $ac_word... " >&6; }
4935 if ${ac_cv_path_CHMOD+:} false; then :
4936   $as_echo_n "(cached) " >&6
4937 else
4938   case $CHMOD in
4939   [\\/]* | ?:[\\/]*)
4940   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
4941   ;;
4942   *)
4943   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4944 for as_dir in $PATH
4945 do
4946   IFS=$as_save_IFS
4947   test -z "$as_dir" && as_dir=.
4948     for ac_exec_ext in '' $ac_executable_extensions; do
4949   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4950     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
4951     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4952     break 2
4953   fi
4954 done
4955   done
4956 IFS=$as_save_IFS
4957 
4958   ;;
4959 esac
4960 fi
4961 CHMOD=$ac_cv_path_CHMOD
4962 if test -n "$CHMOD"; then
4963   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
4964 $as_echo "$CHMOD" >&6; }
4965 else
4966   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4967 $as_echo "no" >&6; }
4968 fi
4969 
4970 
4971   test -n "$CHMOD" && break
4972 done
4973 
4974     else
4975       # If it succeeded, then it was overridden by the user. We will use it
4976       # for the tool.
4977 
4978       # First remove it from the list of overridden variables, so we can test
4979       # for unknown variables in the end.
4980       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4981 
4982       # Check if the provided tool contains a complete path.
4983       tool_specified="$CHMOD"
4984       tool_basename="${tool_specified##*/}"
4985       if test "x$tool_basename" = "x$tool_specified"; then
4986         # A command without a complete path is provided, search $PATH.
4987         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
4988 $as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
4989         # Extract the first word of "$tool_basename", so it can be a program name with args.
4990 set dummy $tool_basename; ac_word=$2
4991 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4992 $as_echo_n "checking for $ac_word... " >&6; }
4993 if ${ac_cv_path_CHMOD+:} false; then :
4994   $as_echo_n "(cached) " >&6
4995 else
4996   case $CHMOD in
4997   [\\/]* | ?:[\\/]*)
4998   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
4999   ;;
5000   *)
5001   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5002 for as_dir in $PATH
5003 do
5004   IFS=$as_save_IFS
5005   test -z "$as_dir" && as_dir=.
5006     for ac_exec_ext in '' $ac_executable_extensions; do
5007   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5008     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5009     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5010     break 2
5011   fi
5012 done
5013   done
5014 IFS=$as_save_IFS
5015 
5016   ;;
5017 esac
5018 fi
5019 CHMOD=$ac_cv_path_CHMOD
5020 if test -n "$CHMOD"; then
5021   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5022 $as_echo "$CHMOD" >&6; }
5023 else
5024   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5025 $as_echo "no" >&6; }
5026 fi
5027 
5028 
5029         if test "x$CHMOD" = x; then
5030           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5031         fi
5032       else
5033         # Otherwise we believe it is a complete path. Use it as it is.
5034         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
5035 $as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
5036         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5037 $as_echo_n "checking for CHMOD... " >&6; }
5038         if test ! -x "$tool_specified"; then
5039           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5040 $as_echo "not found" >&6; }
5041           as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
5042         fi
5043         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5044 $as_echo "$tool_specified" >&6; }
5045       fi
5046     fi
5047   fi
5048 
5049 
5050 
5051   if test "x$CHMOD" = x; then
5052     as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
5053   fi
5054 
5055 
5056 
5057 
5058 
5059   # Publish this variable in the help.
5060 
5061 
5062   if test "x$CMP" = x; then
5063     # The variable is not set by user, try to locate tool using the code snippet
5064     for ac_prog in cmp
5065 do
5066   # Extract the first word of "$ac_prog", so it can be a program name with args.
5067 set dummy $ac_prog; ac_word=$2
5068 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5069 $as_echo_n "checking for $ac_word... " >&6; }
5070 if ${ac_cv_path_CMP+:} false; then :
5071   $as_echo_n "(cached) " >&6
5072 else
5073   case $CMP in
5074   [\\/]* | ?:[\\/]*)
5075   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5076   ;;
5077   *)
5078   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5079 for as_dir in $PATH
5080 do
5081   IFS=$as_save_IFS
5082   test -z "$as_dir" && as_dir=.
5083     for ac_exec_ext in '' $ac_executable_extensions; do
5084   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5085     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5086     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5087     break 2
5088   fi
5089 done
5090   done
5091 IFS=$as_save_IFS
5092 
5093   ;;
5094 esac
5095 fi
5096 CMP=$ac_cv_path_CMP
5097 if test -n "$CMP"; then
5098   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5099 $as_echo "$CMP" >&6; }
5100 else
5101   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5102 $as_echo "no" >&6; }
5103 fi
5104 
5105 
5106   test -n "$CMP" && break
5107 done
5108 
5109   else
5110     # The variable is set, but is it from the command line or the environment?
5111 
5112     # Try to remove the string !CMP! from our list.
5113     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
5114     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5115       # If it failed, the variable was not from the command line. Ignore it,
5116       # but warn the user (except for BASH, which is always set by the calling BASH).
5117       if test "xCMP" != xBASH; then
5118         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
5119 $as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
5120       fi
5121       # Try to locate tool using the code snippet
5122       for ac_prog in cmp
5123 do
5124   # Extract the first word of "$ac_prog", so it can be a program name with args.
5125 set dummy $ac_prog; ac_word=$2
5126 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5127 $as_echo_n "checking for $ac_word... " >&6; }
5128 if ${ac_cv_path_CMP+:} false; then :
5129   $as_echo_n "(cached) " >&6
5130 else
5131   case $CMP in
5132   [\\/]* | ?:[\\/]*)
5133   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5134   ;;
5135   *)
5136   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5137 for as_dir in $PATH
5138 do
5139   IFS=$as_save_IFS
5140   test -z "$as_dir" && as_dir=.
5141     for ac_exec_ext in '' $ac_executable_extensions; do
5142   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5143     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5144     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5145     break 2
5146   fi
5147 done
5148   done
5149 IFS=$as_save_IFS
5150 
5151   ;;
5152 esac
5153 fi
5154 CMP=$ac_cv_path_CMP
5155 if test -n "$CMP"; then
5156   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5157 $as_echo "$CMP" >&6; }
5158 else
5159   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5160 $as_echo "no" >&6; }
5161 fi
5162 
5163 
5164   test -n "$CMP" && break
5165 done
5166 
5167     else
5168       # If it succeeded, then it was overridden by the user. We will use it
5169       # for the tool.
5170 
5171       # First remove it from the list of overridden variables, so we can test
5172       # for unknown variables in the end.
5173       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5174 
5175       # Check if the provided tool contains a complete path.
5176       tool_specified="$CMP"
5177       tool_basename="${tool_specified##*/}"
5178       if test "x$tool_basename" = "x$tool_specified"; then
5179         # A command without a complete path is provided, search $PATH.
5180         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
5181 $as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
5182         # Extract the first word of "$tool_basename", so it can be a program name with args.
5183 set dummy $tool_basename; ac_word=$2
5184 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5185 $as_echo_n "checking for $ac_word... " >&6; }
5186 if ${ac_cv_path_CMP+:} false; then :
5187   $as_echo_n "(cached) " >&6
5188 else
5189   case $CMP in
5190   [\\/]* | ?:[\\/]*)
5191   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5192   ;;
5193   *)
5194   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5195 for as_dir in $PATH
5196 do
5197   IFS=$as_save_IFS
5198   test -z "$as_dir" && as_dir=.
5199     for ac_exec_ext in '' $ac_executable_extensions; do
5200   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5201     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5202     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5203     break 2
5204   fi
5205 done
5206   done
5207 IFS=$as_save_IFS
5208 
5209   ;;
5210 esac
5211 fi
5212 CMP=$ac_cv_path_CMP
5213 if test -n "$CMP"; then
5214   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5215 $as_echo "$CMP" >&6; }
5216 else
5217   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5218 $as_echo "no" >&6; }
5219 fi
5220 
5221 
5222         if test "x$CMP" = x; then
5223           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5224         fi
5225       else
5226         # Otherwise we believe it is a complete path. Use it as it is.
5227         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
5228 $as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
5229         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
5230 $as_echo_n "checking for CMP... " >&6; }
5231         if test ! -x "$tool_specified"; then
5232           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5233 $as_echo "not found" >&6; }
5234           as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
5235         fi
5236         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5237 $as_echo "$tool_specified" >&6; }
5238       fi
5239     fi
5240   fi
5241 
5242 
5243 
5244   if test "x$CMP" = x; then
5245     as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
5246   fi
5247 
5248 
5249 
5250 
5251 
5252   # Publish this variable in the help.
5253 
5254 
5255   if test "x$COMM" = x; then
5256     # The variable is not set by user, try to locate tool using the code snippet
5257     for ac_prog in comm
5258 do
5259   # Extract the first word of "$ac_prog", so it can be a program name with args.
5260 set dummy $ac_prog; ac_word=$2
5261 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5262 $as_echo_n "checking for $ac_word... " >&6; }
5263 if ${ac_cv_path_COMM+:} false; then :
5264   $as_echo_n "(cached) " >&6
5265 else
5266   case $COMM in
5267   [\\/]* | ?:[\\/]*)
5268   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5269   ;;
5270   *)
5271   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5272 for as_dir in $PATH
5273 do
5274   IFS=$as_save_IFS
5275   test -z "$as_dir" && as_dir=.
5276     for ac_exec_ext in '' $ac_executable_extensions; do
5277   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5278     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5279     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5280     break 2
5281   fi
5282 done
5283   done
5284 IFS=$as_save_IFS
5285 
5286   ;;
5287 esac
5288 fi
5289 COMM=$ac_cv_path_COMM
5290 if test -n "$COMM"; then
5291   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5292 $as_echo "$COMM" >&6; }
5293 else
5294   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5295 $as_echo "no" >&6; }
5296 fi
5297 
5298 
5299   test -n "$COMM" && break
5300 done
5301 
5302   else
5303     # The variable is set, but is it from the command line or the environment?
5304 
5305     # Try to remove the string !COMM! from our list.
5306     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
5307     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5308       # If it failed, the variable was not from the command line. Ignore it,
5309       # but warn the user (except for BASH, which is always set by the calling BASH).
5310       if test "xCOMM" != xBASH; then
5311         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
5312 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
5313       fi
5314       # Try to locate tool using the code snippet
5315       for ac_prog in comm
5316 do
5317   # Extract the first word of "$ac_prog", so it can be a program name with args.
5318 set dummy $ac_prog; ac_word=$2
5319 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5320 $as_echo_n "checking for $ac_word... " >&6; }
5321 if ${ac_cv_path_COMM+:} false; then :
5322   $as_echo_n "(cached) " >&6
5323 else
5324   case $COMM in
5325   [\\/]* | ?:[\\/]*)
5326   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5327   ;;
5328   *)
5329   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5330 for as_dir in $PATH
5331 do
5332   IFS=$as_save_IFS
5333   test -z "$as_dir" && as_dir=.
5334     for ac_exec_ext in '' $ac_executable_extensions; do
5335   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5336     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5337     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5338     break 2
5339   fi
5340 done
5341   done
5342 IFS=$as_save_IFS
5343 
5344   ;;
5345 esac
5346 fi
5347 COMM=$ac_cv_path_COMM
5348 if test -n "$COMM"; then
5349   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5350 $as_echo "$COMM" >&6; }
5351 else
5352   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5353 $as_echo "no" >&6; }
5354 fi
5355 
5356 
5357   test -n "$COMM" && break
5358 done
5359 
5360     else
5361       # If it succeeded, then it was overridden by the user. We will use it
5362       # for the tool.
5363 
5364       # First remove it from the list of overridden variables, so we can test
5365       # for unknown variables in the end.
5366       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5367 
5368       # Check if the provided tool contains a complete path.
5369       tool_specified="$COMM"
5370       tool_basename="${tool_specified##*/}"
5371       if test "x$tool_basename" = "x$tool_specified"; then
5372         # A command without a complete path is provided, search $PATH.
5373         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
5374 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
5375         # Extract the first word of "$tool_basename", so it can be a program name with args.
5376 set dummy $tool_basename; ac_word=$2
5377 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5378 $as_echo_n "checking for $ac_word... " >&6; }
5379 if ${ac_cv_path_COMM+:} false; then :
5380   $as_echo_n "(cached) " >&6
5381 else
5382   case $COMM in
5383   [\\/]* | ?:[\\/]*)
5384   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5385   ;;
5386   *)
5387   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5388 for as_dir in $PATH
5389 do
5390   IFS=$as_save_IFS
5391   test -z "$as_dir" && as_dir=.
5392     for ac_exec_ext in '' $ac_executable_extensions; do
5393   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5394     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5395     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5396     break 2
5397   fi
5398 done
5399   done
5400 IFS=$as_save_IFS
5401 
5402   ;;
5403 esac
5404 fi
5405 COMM=$ac_cv_path_COMM
5406 if test -n "$COMM"; then
5407   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5408 $as_echo "$COMM" >&6; }
5409 else
5410   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5411 $as_echo "no" >&6; }
5412 fi
5413 
5414 
5415         if test "x$COMM" = x; then
5416           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5417         fi
5418       else
5419         # Otherwise we believe it is a complete path. Use it as it is.
5420         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
5421 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
5422         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
5423 $as_echo_n "checking for COMM... " >&6; }
5424         if test ! -x "$tool_specified"; then
5425           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5426 $as_echo "not found" >&6; }
5427           as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
5428         fi
5429         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5430 $as_echo "$tool_specified" >&6; }
5431       fi
5432     fi
5433   fi
5434 
5435 
5436 
5437   if test "x$COMM" = x; then
5438     as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
5439   fi
5440 
5441 
5442 
5443 
5444 
5445   # Publish this variable in the help.
5446 
5447 
5448   if test "x$CP" = x; then
5449     # The variable is not set by user, try to locate tool using the code snippet
5450     for ac_prog in cp
5451 do
5452   # Extract the first word of "$ac_prog", so it can be a program name with args.
5453 set dummy $ac_prog; ac_word=$2
5454 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5455 $as_echo_n "checking for $ac_word... " >&6; }
5456 if ${ac_cv_path_CP+:} false; then :
5457   $as_echo_n "(cached) " >&6
5458 else
5459   case $CP in
5460   [\\/]* | ?:[\\/]*)
5461   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5462   ;;
5463   *)
5464   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5465 for as_dir in $PATH
5466 do
5467   IFS=$as_save_IFS
5468   test -z "$as_dir" && as_dir=.
5469     for ac_exec_ext in '' $ac_executable_extensions; do
5470   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5471     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5472     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5473     break 2
5474   fi
5475 done
5476   done
5477 IFS=$as_save_IFS
5478 
5479   ;;
5480 esac
5481 fi
5482 CP=$ac_cv_path_CP
5483 if test -n "$CP"; then
5484   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5485 $as_echo "$CP" >&6; }
5486 else
5487   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5488 $as_echo "no" >&6; }
5489 fi
5490 
5491 
5492   test -n "$CP" && break
5493 done
5494 
5495   else
5496     # The variable is set, but is it from the command line or the environment?
5497 
5498     # Try to remove the string !CP! from our list.
5499     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
5500     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5501       # If it failed, the variable was not from the command line. Ignore it,
5502       # but warn the user (except for BASH, which is always set by the calling BASH).
5503       if test "xCP" != xBASH; then
5504         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
5505 $as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
5506       fi
5507       # Try to locate tool using the code snippet
5508       for ac_prog in cp
5509 do
5510   # Extract the first word of "$ac_prog", so it can be a program name with args.
5511 set dummy $ac_prog; ac_word=$2
5512 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5513 $as_echo_n "checking for $ac_word... " >&6; }
5514 if ${ac_cv_path_CP+:} false; then :
5515   $as_echo_n "(cached) " >&6
5516 else
5517   case $CP in
5518   [\\/]* | ?:[\\/]*)
5519   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5520   ;;
5521   *)
5522   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5523 for as_dir in $PATH
5524 do
5525   IFS=$as_save_IFS
5526   test -z "$as_dir" && as_dir=.
5527     for ac_exec_ext in '' $ac_executable_extensions; do
5528   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5529     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5530     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5531     break 2
5532   fi
5533 done
5534   done
5535 IFS=$as_save_IFS
5536 
5537   ;;
5538 esac
5539 fi
5540 CP=$ac_cv_path_CP
5541 if test -n "$CP"; then
5542   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5543 $as_echo "$CP" >&6; }
5544 else
5545   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5546 $as_echo "no" >&6; }
5547 fi
5548 
5549 
5550   test -n "$CP" && break
5551 done
5552 
5553     else
5554       # If it succeeded, then it was overridden by the user. We will use it
5555       # for the tool.
5556 
5557       # First remove it from the list of overridden variables, so we can test
5558       # for unknown variables in the end.
5559       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5560 
5561       # Check if the provided tool contains a complete path.
5562       tool_specified="$CP"
5563       tool_basename="${tool_specified##*/}"
5564       if test "x$tool_basename" = "x$tool_specified"; then
5565         # A command without a complete path is provided, search $PATH.
5566         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
5567 $as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
5568         # Extract the first word of "$tool_basename", so it can be a program name with args.
5569 set dummy $tool_basename; ac_word=$2
5570 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5571 $as_echo_n "checking for $ac_word... " >&6; }
5572 if ${ac_cv_path_CP+:} false; then :
5573   $as_echo_n "(cached) " >&6
5574 else
5575   case $CP in
5576   [\\/]* | ?:[\\/]*)
5577   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5578   ;;
5579   *)
5580   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5581 for as_dir in $PATH
5582 do
5583   IFS=$as_save_IFS
5584   test -z "$as_dir" && as_dir=.
5585     for ac_exec_ext in '' $ac_executable_extensions; do
5586   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5587     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5588     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5589     break 2
5590   fi
5591 done
5592   done
5593 IFS=$as_save_IFS
5594 
5595   ;;
5596 esac
5597 fi
5598 CP=$ac_cv_path_CP
5599 if test -n "$CP"; then
5600   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5601 $as_echo "$CP" >&6; }
5602 else
5603   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5604 $as_echo "no" >&6; }
5605 fi
5606 
5607 
5608         if test "x$CP" = x; then
5609           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5610         fi
5611       else
5612         # Otherwise we believe it is a complete path. Use it as it is.
5613         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
5614 $as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
5615         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
5616 $as_echo_n "checking for CP... " >&6; }
5617         if test ! -x "$tool_specified"; then
5618           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5619 $as_echo "not found" >&6; }
5620           as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
5621         fi
5622         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5623 $as_echo "$tool_specified" >&6; }
5624       fi
5625     fi
5626   fi
5627 
5628 
5629 
5630   if test "x$CP" = x; then
5631     as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
5632   fi
5633 
5634 
5635 
5636 
5637 
5638   # Publish this variable in the help.
5639 
5640 
5641   if test "x$CPIO" = x; then
5642     # The variable is not set by user, try to locate tool using the code snippet
5643     for ac_prog in cpio
5644 do
5645   # Extract the first word of "$ac_prog", so it can be a program name with args.
5646 set dummy $ac_prog; ac_word=$2
5647 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5648 $as_echo_n "checking for $ac_word... " >&6; }
5649 if ${ac_cv_path_CPIO+:} false; then :
5650   $as_echo_n "(cached) " >&6
5651 else
5652   case $CPIO in
5653   [\\/]* | ?:[\\/]*)
5654   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
5655   ;;
5656   *)
5657   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5658 for as_dir in $PATH
5659 do
5660   IFS=$as_save_IFS
5661   test -z "$as_dir" && as_dir=.
5662     for ac_exec_ext in '' $ac_executable_extensions; do
5663   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5664     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
5665     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5666     break 2
5667   fi
5668 done
5669   done
5670 IFS=$as_save_IFS
5671 
5672   ;;
5673 esac
5674 fi
5675 CPIO=$ac_cv_path_CPIO
5676 if test -n "$CPIO"; then
5677   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
5678 $as_echo "$CPIO" >&6; }
5679 else
5680   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5681 $as_echo "no" >&6; }
5682 fi
5683 
5684 
5685   test -n "$CPIO" && break
5686 done
5687 
5688   else
5689     # The variable is set, but is it from the command line or the environment?
5690 
5691     # Try to remove the string !CPIO! from our list.
5692     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
5693     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5694       # If it failed, the variable was not from the command line. Ignore it,
5695       # but warn the user (except for BASH, which is always set by the calling BASH).
5696       if test "xCPIO" != xBASH; then
5697         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
5698 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
5699       fi
5700       # Try to locate tool using the code snippet
5701       for ac_prog in cpio
5702 do
5703   # Extract the first word of "$ac_prog", so it can be a program name with args.
5704 set dummy $ac_prog; ac_word=$2
5705 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5706 $as_echo_n "checking for $ac_word... " >&6; }
5707 if ${ac_cv_path_CPIO+:} false; then :
5708   $as_echo_n "(cached) " >&6
5709 else
5710   case $CPIO in
5711   [\\/]* | ?:[\\/]*)
5712   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
5713   ;;
5714   *)
5715   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5716 for as_dir in $PATH
5717 do
5718   IFS=$as_save_IFS
5719   test -z "$as_dir" && as_dir=.
5720     for ac_exec_ext in '' $ac_executable_extensions; do
5721   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5722     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
5723     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5724     break 2
5725   fi
5726 done
5727   done
5728 IFS=$as_save_IFS
5729 
5730   ;;
5731 esac
5732 fi
5733 CPIO=$ac_cv_path_CPIO
5734 if test -n "$CPIO"; then
5735   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
5736 $as_echo "$CPIO" >&6; }
5737 else
5738   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5739 $as_echo "no" >&6; }
5740 fi
5741 
5742 
5743   test -n "$CPIO" && break
5744 done
5745 
5746     else
5747       # If it succeeded, then it was overridden by the user. We will use it
5748       # for the tool.
5749 
5750       # First remove it from the list of overridden variables, so we can test
5751       # for unknown variables in the end.
5752       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5753 
5754       # Check if the provided tool contains a complete path.
5755       tool_specified="$CPIO"
5756       tool_basename="${tool_specified##*/}"
5757       if test "x$tool_basename" = "x$tool_specified"; then
5758         # A command without a complete path is provided, search $PATH.
5759         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
5760 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
5761         # Extract the first word of "$tool_basename", so it can be a program name with args.
5762 set dummy $tool_basename; ac_word=$2
5763 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5764 $as_echo_n "checking for $ac_word... " >&6; }
5765 if ${ac_cv_path_CPIO+:} false; then :
5766   $as_echo_n "(cached) " >&6
5767 else
5768   case $CPIO in
5769   [\\/]* | ?:[\\/]*)
5770   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
5771   ;;
5772   *)
5773   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5774 for as_dir in $PATH
5775 do
5776   IFS=$as_save_IFS
5777   test -z "$as_dir" && as_dir=.
5778     for ac_exec_ext in '' $ac_executable_extensions; do
5779   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5780     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
5781     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5782     break 2
5783   fi
5784 done
5785   done
5786 IFS=$as_save_IFS
5787 
5788   ;;
5789 esac
5790 fi
5791 CPIO=$ac_cv_path_CPIO
5792 if test -n "$CPIO"; then
5793   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
5794 $as_echo "$CPIO" >&6; }
5795 else
5796   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5797 $as_echo "no" >&6; }
5798 fi
5799 
5800 
5801         if test "x$CPIO" = x; then
5802           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5803         fi
5804       else
5805         # Otherwise we believe it is a complete path. Use it as it is.
5806         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
5807 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
5808         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
5809 $as_echo_n "checking for CPIO... " >&6; }
5810         if test ! -x "$tool_specified"; then
5811           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5812 $as_echo "not found" >&6; }
5813           as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
5814         fi
5815         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5816 $as_echo "$tool_specified" >&6; }
5817       fi
5818     fi
5819   fi
5820 
5821 
5822 
5823   if test "x$CPIO" = x; then
5824     as_fn_error $? "Could not find required tool for CPIO" "$LINENO" 5
5825   fi
5826 
5827 
5828 
5829 
5830 
5831   # Publish this variable in the help.
5832 
5833 
5834   if test "x$CUT" = x; then
5835     # The variable is not set by user, try to locate tool using the code snippet
5836     for ac_prog in cut
5837 do
5838   # Extract the first word of "$ac_prog", so it can be a program name with args.
5839 set dummy $ac_prog; ac_word=$2
5840 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5841 $as_echo_n "checking for $ac_word... " >&6; }
5842 if ${ac_cv_path_CUT+:} false; then :
5843   $as_echo_n "(cached) " >&6
5844 else
5845   case $CUT in
5846   [\\/]* | ?:[\\/]*)
5847   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5848   ;;
5849   *)
5850   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5851 for as_dir in $PATH
5852 do
5853   IFS=$as_save_IFS
5854   test -z "$as_dir" && as_dir=.
5855     for ac_exec_ext in '' $ac_executable_extensions; do
5856   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5857     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5858     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5859     break 2
5860   fi
5861 done
5862   done
5863 IFS=$as_save_IFS
5864 
5865   ;;
5866 esac
5867 fi
5868 CUT=$ac_cv_path_CUT
5869 if test -n "$CUT"; then
5870   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5871 $as_echo "$CUT" >&6; }
5872 else
5873   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5874 $as_echo "no" >&6; }
5875 fi
5876 
5877 
5878   test -n "$CUT" && break
5879 done
5880 
5881   else
5882     # The variable is set, but is it from the command line or the environment?
5883 
5884     # Try to remove the string !CUT! from our list.
5885     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
5886     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5887       # If it failed, the variable was not from the command line. Ignore it,
5888       # but warn the user (except for BASH, which is always set by the calling BASH).
5889       if test "xCUT" != xBASH; then
5890         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
5891 $as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
5892       fi
5893       # Try to locate tool using the code snippet
5894       for ac_prog in cut
5895 do
5896   # Extract the first word of "$ac_prog", so it can be a program name with args.
5897 set dummy $ac_prog; ac_word=$2
5898 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5899 $as_echo_n "checking for $ac_word... " >&6; }
5900 if ${ac_cv_path_CUT+:} false; then :
5901   $as_echo_n "(cached) " >&6
5902 else
5903   case $CUT in
5904   [\\/]* | ?:[\\/]*)
5905   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5906   ;;
5907   *)
5908   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5909 for as_dir in $PATH
5910 do
5911   IFS=$as_save_IFS
5912   test -z "$as_dir" && as_dir=.
5913     for ac_exec_ext in '' $ac_executable_extensions; do
5914   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5915     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5916     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5917     break 2
5918   fi
5919 done
5920   done
5921 IFS=$as_save_IFS
5922 
5923   ;;
5924 esac
5925 fi
5926 CUT=$ac_cv_path_CUT
5927 if test -n "$CUT"; then
5928   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5929 $as_echo "$CUT" >&6; }
5930 else
5931   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5932 $as_echo "no" >&6; }
5933 fi
5934 
5935 
5936   test -n "$CUT" && break
5937 done
5938 
5939     else
5940       # If it succeeded, then it was overridden by the user. We will use it
5941       # for the tool.
5942 
5943       # First remove it from the list of overridden variables, so we can test
5944       # for unknown variables in the end.
5945       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5946 
5947       # Check if the provided tool contains a complete path.
5948       tool_specified="$CUT"
5949       tool_basename="${tool_specified##*/}"
5950       if test "x$tool_basename" = "x$tool_specified"; then
5951         # A command without a complete path is provided, search $PATH.
5952         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
5953 $as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
5954         # Extract the first word of "$tool_basename", so it can be a program name with args.
5955 set dummy $tool_basename; ac_word=$2
5956 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5957 $as_echo_n "checking for $ac_word... " >&6; }
5958 if ${ac_cv_path_CUT+:} false; then :
5959   $as_echo_n "(cached) " >&6
5960 else
5961   case $CUT in
5962   [\\/]* | ?:[\\/]*)
5963   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5964   ;;
5965   *)
5966   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5967 for as_dir in $PATH
5968 do
5969   IFS=$as_save_IFS
5970   test -z "$as_dir" && as_dir=.
5971     for ac_exec_ext in '' $ac_executable_extensions; do
5972   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5973     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5974     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5975     break 2
5976   fi
5977 done
5978   done
5979 IFS=$as_save_IFS
5980 
5981   ;;
5982 esac
5983 fi
5984 CUT=$ac_cv_path_CUT
5985 if test -n "$CUT"; then
5986   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5987 $as_echo "$CUT" >&6; }
5988 else
5989   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5990 $as_echo "no" >&6; }
5991 fi
5992 
5993 
5994         if test "x$CUT" = x; then
5995           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5996         fi
5997       else
5998         # Otherwise we believe it is a complete path. Use it as it is.
5999         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
6000 $as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
6001         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
6002 $as_echo_n "checking for CUT... " >&6; }
6003         if test ! -x "$tool_specified"; then
6004           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6005 $as_echo "not found" >&6; }
6006           as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
6007         fi
6008         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6009 $as_echo "$tool_specified" >&6; }
6010       fi
6011     fi
6012   fi
6013 
6014 
6015 
6016   if test "x$CUT" = x; then
6017     as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
6018   fi
6019 
6020 
6021 
6022 
6023 
6024   # Publish this variable in the help.
6025 
6026 
6027   if test "x$DATE" = x; then
6028     # The variable is not set by user, try to locate tool using the code snippet
6029     for ac_prog in date
6030 do
6031   # Extract the first word of "$ac_prog", so it can be a program name with args.
6032 set dummy $ac_prog; ac_word=$2
6033 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6034 $as_echo_n "checking for $ac_word... " >&6; }
6035 if ${ac_cv_path_DATE+:} false; then :
6036   $as_echo_n "(cached) " >&6
6037 else
6038   case $DATE in
6039   [\\/]* | ?:[\\/]*)
6040   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6041   ;;
6042   *)
6043   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6044 for as_dir in $PATH
6045 do
6046   IFS=$as_save_IFS
6047   test -z "$as_dir" && as_dir=.
6048     for ac_exec_ext in '' $ac_executable_extensions; do
6049   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6050     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6051     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6052     break 2
6053   fi
6054 done
6055   done
6056 IFS=$as_save_IFS
6057 
6058   ;;
6059 esac
6060 fi
6061 DATE=$ac_cv_path_DATE
6062 if test -n "$DATE"; then
6063   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6064 $as_echo "$DATE" >&6; }
6065 else
6066   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6067 $as_echo "no" >&6; }
6068 fi
6069 
6070 
6071   test -n "$DATE" && break
6072 done
6073 
6074   else
6075     # The variable is set, but is it from the command line or the environment?
6076 
6077     # Try to remove the string !DATE! from our list.
6078     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
6079     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6080       # If it failed, the variable was not from the command line. Ignore it,
6081       # but warn the user (except for BASH, which is always set by the calling BASH).
6082       if test "xDATE" != xBASH; then
6083         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
6084 $as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
6085       fi
6086       # Try to locate tool using the code snippet
6087       for ac_prog in date
6088 do
6089   # Extract the first word of "$ac_prog", so it can be a program name with args.
6090 set dummy $ac_prog; ac_word=$2
6091 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6092 $as_echo_n "checking for $ac_word... " >&6; }
6093 if ${ac_cv_path_DATE+:} false; then :
6094   $as_echo_n "(cached) " >&6
6095 else
6096   case $DATE in
6097   [\\/]* | ?:[\\/]*)
6098   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6099   ;;
6100   *)
6101   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6102 for as_dir in $PATH
6103 do
6104   IFS=$as_save_IFS
6105   test -z "$as_dir" && as_dir=.
6106     for ac_exec_ext in '' $ac_executable_extensions; do
6107   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6108     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6109     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6110     break 2
6111   fi
6112 done
6113   done
6114 IFS=$as_save_IFS
6115 
6116   ;;
6117 esac
6118 fi
6119 DATE=$ac_cv_path_DATE
6120 if test -n "$DATE"; then
6121   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6122 $as_echo "$DATE" >&6; }
6123 else
6124   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6125 $as_echo "no" >&6; }
6126 fi
6127 
6128 
6129   test -n "$DATE" && break
6130 done
6131 
6132     else
6133       # If it succeeded, then it was overridden by the user. We will use it
6134       # for the tool.
6135 
6136       # First remove it from the list of overridden variables, so we can test
6137       # for unknown variables in the end.
6138       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6139 
6140       # Check if the provided tool contains a complete path.
6141       tool_specified="$DATE"
6142       tool_basename="${tool_specified##*/}"
6143       if test "x$tool_basename" = "x$tool_specified"; then
6144         # A command without a complete path is provided, search $PATH.
6145         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
6146 $as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
6147         # Extract the first word of "$tool_basename", so it can be a program name with args.
6148 set dummy $tool_basename; ac_word=$2
6149 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6150 $as_echo_n "checking for $ac_word... " >&6; }
6151 if ${ac_cv_path_DATE+:} false; then :
6152   $as_echo_n "(cached) " >&6
6153 else
6154   case $DATE in
6155   [\\/]* | ?:[\\/]*)
6156   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6157   ;;
6158   *)
6159   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6160 for as_dir in $PATH
6161 do
6162   IFS=$as_save_IFS
6163   test -z "$as_dir" && as_dir=.
6164     for ac_exec_ext in '' $ac_executable_extensions; do
6165   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6166     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6167     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6168     break 2
6169   fi
6170 done
6171   done
6172 IFS=$as_save_IFS
6173 
6174   ;;
6175 esac
6176 fi
6177 DATE=$ac_cv_path_DATE
6178 if test -n "$DATE"; then
6179   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6180 $as_echo "$DATE" >&6; }
6181 else
6182   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6183 $as_echo "no" >&6; }
6184 fi
6185 
6186 
6187         if test "x$DATE" = x; then
6188           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6189         fi
6190       else
6191         # Otherwise we believe it is a complete path. Use it as it is.
6192         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
6193 $as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
6194         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6195 $as_echo_n "checking for DATE... " >&6; }
6196         if test ! -x "$tool_specified"; then
6197           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6198 $as_echo "not found" >&6; }
6199           as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
6200         fi
6201         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6202 $as_echo "$tool_specified" >&6; }
6203       fi
6204     fi
6205   fi
6206 
6207 
6208 
6209   if test "x$DATE" = x; then
6210     as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
6211   fi
6212 
6213 
6214 
6215 
6216 
6217   # Publish this variable in the help.
6218 
6219 
6220   if test "x$DIFF" = x; then
6221     # The variable is not set by user, try to locate tool using the code snippet
6222     for ac_prog in gdiff diff
6223 do
6224   # Extract the first word of "$ac_prog", so it can be a program name with args.
6225 set dummy $ac_prog; ac_word=$2
6226 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6227 $as_echo_n "checking for $ac_word... " >&6; }
6228 if ${ac_cv_path_DIFF+:} false; then :
6229   $as_echo_n "(cached) " >&6
6230 else
6231   case $DIFF in
6232   [\\/]* | ?:[\\/]*)
6233   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6234   ;;
6235   *)
6236   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6237 for as_dir in $PATH
6238 do
6239   IFS=$as_save_IFS
6240   test -z "$as_dir" && as_dir=.
6241     for ac_exec_ext in '' $ac_executable_extensions; do
6242   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6243     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6244     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6245     break 2
6246   fi
6247 done
6248   done
6249 IFS=$as_save_IFS
6250 
6251   ;;
6252 esac
6253 fi
6254 DIFF=$ac_cv_path_DIFF
6255 if test -n "$DIFF"; then
6256   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6257 $as_echo "$DIFF" >&6; }
6258 else
6259   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6260 $as_echo "no" >&6; }
6261 fi
6262 
6263 
6264   test -n "$DIFF" && break
6265 done
6266 
6267   else
6268     # The variable is set, but is it from the command line or the environment?
6269 
6270     # Try to remove the string !DIFF! from our list.
6271     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
6272     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6273       # If it failed, the variable was not from the command line. Ignore it,
6274       # but warn the user (except for BASH, which is always set by the calling BASH).
6275       if test "xDIFF" != xBASH; then
6276         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
6277 $as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
6278       fi
6279       # Try to locate tool using the code snippet
6280       for ac_prog in gdiff diff
6281 do
6282   # Extract the first word of "$ac_prog", so it can be a program name with args.
6283 set dummy $ac_prog; ac_word=$2
6284 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6285 $as_echo_n "checking for $ac_word... " >&6; }
6286 if ${ac_cv_path_DIFF+:} false; then :
6287   $as_echo_n "(cached) " >&6
6288 else
6289   case $DIFF in
6290   [\\/]* | ?:[\\/]*)
6291   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6292   ;;
6293   *)
6294   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6295 for as_dir in $PATH
6296 do
6297   IFS=$as_save_IFS
6298   test -z "$as_dir" && as_dir=.
6299     for ac_exec_ext in '' $ac_executable_extensions; do
6300   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6301     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6302     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6303     break 2
6304   fi
6305 done
6306   done
6307 IFS=$as_save_IFS
6308 
6309   ;;
6310 esac
6311 fi
6312 DIFF=$ac_cv_path_DIFF
6313 if test -n "$DIFF"; then
6314   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6315 $as_echo "$DIFF" >&6; }
6316 else
6317   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6318 $as_echo "no" >&6; }
6319 fi
6320 
6321 
6322   test -n "$DIFF" && break
6323 done
6324 
6325     else
6326       # If it succeeded, then it was overridden by the user. We will use it
6327       # for the tool.
6328 
6329       # First remove it from the list of overridden variables, so we can test
6330       # for unknown variables in the end.
6331       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6332 
6333       # Check if the provided tool contains a complete path.
6334       tool_specified="$DIFF"
6335       tool_basename="${tool_specified##*/}"
6336       if test "x$tool_basename" = "x$tool_specified"; then
6337         # A command without a complete path is provided, search $PATH.
6338         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
6339 $as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
6340         # Extract the first word of "$tool_basename", so it can be a program name with args.
6341 set dummy $tool_basename; ac_word=$2
6342 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6343 $as_echo_n "checking for $ac_word... " >&6; }
6344 if ${ac_cv_path_DIFF+:} false; then :
6345   $as_echo_n "(cached) " >&6
6346 else
6347   case $DIFF in
6348   [\\/]* | ?:[\\/]*)
6349   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6350   ;;
6351   *)
6352   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6353 for as_dir in $PATH
6354 do
6355   IFS=$as_save_IFS
6356   test -z "$as_dir" && as_dir=.
6357     for ac_exec_ext in '' $ac_executable_extensions; do
6358   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6359     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6360     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6361     break 2
6362   fi
6363 done
6364   done
6365 IFS=$as_save_IFS
6366 
6367   ;;
6368 esac
6369 fi
6370 DIFF=$ac_cv_path_DIFF
6371 if test -n "$DIFF"; then
6372   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6373 $as_echo "$DIFF" >&6; }
6374 else
6375   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6376 $as_echo "no" >&6; }
6377 fi
6378 
6379 
6380         if test "x$DIFF" = x; then
6381           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6382         fi
6383       else
6384         # Otherwise we believe it is a complete path. Use it as it is.
6385         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
6386 $as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
6387         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
6388 $as_echo_n "checking for DIFF... " >&6; }
6389         if test ! -x "$tool_specified"; then
6390           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6391 $as_echo "not found" >&6; }
6392           as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
6393         fi
6394         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6395 $as_echo "$tool_specified" >&6; }
6396       fi
6397     fi
6398   fi
6399 
6400 
6401 
6402   if test "x$DIFF" = x; then
6403     as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
6404   fi
6405 
6406 
6407 
6408 
6409 
6410   # Publish this variable in the help.
6411 
6412 
6413   if test "x$DIRNAME" = x; then
6414     # The variable is not set by user, try to locate tool using the code snippet
6415     for ac_prog in dirname
6416 do
6417   # Extract the first word of "$ac_prog", so it can be a program name with args.
6418 set dummy $ac_prog; ac_word=$2
6419 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6420 $as_echo_n "checking for $ac_word... " >&6; }
6421 if ${ac_cv_path_DIRNAME+:} false; then :
6422   $as_echo_n "(cached) " >&6
6423 else
6424   case $DIRNAME in
6425   [\\/]* | ?:[\\/]*)
6426   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6427   ;;
6428   *)
6429   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6430 for as_dir in $PATH
6431 do
6432   IFS=$as_save_IFS
6433   test -z "$as_dir" && as_dir=.
6434     for ac_exec_ext in '' $ac_executable_extensions; do
6435   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6436     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6437     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6438     break 2
6439   fi
6440 done
6441   done
6442 IFS=$as_save_IFS
6443 
6444   ;;
6445 esac
6446 fi
6447 DIRNAME=$ac_cv_path_DIRNAME
6448 if test -n "$DIRNAME"; then
6449   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6450 $as_echo "$DIRNAME" >&6; }
6451 else
6452   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6453 $as_echo "no" >&6; }
6454 fi
6455 
6456 
6457   test -n "$DIRNAME" && break
6458 done
6459 
6460   else
6461     # The variable is set, but is it from the command line or the environment?
6462 
6463     # Try to remove the string !DIRNAME! from our list.
6464     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
6465     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6466       # If it failed, the variable was not from the command line. Ignore it,
6467       # but warn the user (except for BASH, which is always set by the calling BASH).
6468       if test "xDIRNAME" != xBASH; then
6469         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
6470 $as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
6471       fi
6472       # Try to locate tool using the code snippet
6473       for ac_prog in dirname
6474 do
6475   # Extract the first word of "$ac_prog", so it can be a program name with args.
6476 set dummy $ac_prog; ac_word=$2
6477 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6478 $as_echo_n "checking for $ac_word... " >&6; }
6479 if ${ac_cv_path_DIRNAME+:} false; then :
6480   $as_echo_n "(cached) " >&6
6481 else
6482   case $DIRNAME in
6483   [\\/]* | ?:[\\/]*)
6484   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6485   ;;
6486   *)
6487   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6488 for as_dir in $PATH
6489 do
6490   IFS=$as_save_IFS
6491   test -z "$as_dir" && as_dir=.
6492     for ac_exec_ext in '' $ac_executable_extensions; do
6493   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6494     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6495     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6496     break 2
6497   fi
6498 done
6499   done
6500 IFS=$as_save_IFS
6501 
6502   ;;
6503 esac
6504 fi
6505 DIRNAME=$ac_cv_path_DIRNAME
6506 if test -n "$DIRNAME"; then
6507   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6508 $as_echo "$DIRNAME" >&6; }
6509 else
6510   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6511 $as_echo "no" >&6; }
6512 fi
6513 
6514 
6515   test -n "$DIRNAME" && break
6516 done
6517 
6518     else
6519       # If it succeeded, then it was overridden by the user. We will use it
6520       # for the tool.
6521 
6522       # First remove it from the list of overridden variables, so we can test
6523       # for unknown variables in the end.
6524       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6525 
6526       # Check if the provided tool contains a complete path.
6527       tool_specified="$DIRNAME"
6528       tool_basename="${tool_specified##*/}"
6529       if test "x$tool_basename" = "x$tool_specified"; then
6530         # A command without a complete path is provided, search $PATH.
6531         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
6532 $as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
6533         # Extract the first word of "$tool_basename", so it can be a program name with args.
6534 set dummy $tool_basename; ac_word=$2
6535 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6536 $as_echo_n "checking for $ac_word... " >&6; }
6537 if ${ac_cv_path_DIRNAME+:} false; then :
6538   $as_echo_n "(cached) " >&6
6539 else
6540   case $DIRNAME in
6541   [\\/]* | ?:[\\/]*)
6542   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6543   ;;
6544   *)
6545   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6546 for as_dir in $PATH
6547 do
6548   IFS=$as_save_IFS
6549   test -z "$as_dir" && as_dir=.
6550     for ac_exec_ext in '' $ac_executable_extensions; do
6551   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6552     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6553     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6554     break 2
6555   fi
6556 done
6557   done
6558 IFS=$as_save_IFS
6559 
6560   ;;
6561 esac
6562 fi
6563 DIRNAME=$ac_cv_path_DIRNAME
6564 if test -n "$DIRNAME"; then
6565   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6566 $as_echo "$DIRNAME" >&6; }
6567 else
6568   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6569 $as_echo "no" >&6; }
6570 fi
6571 
6572 
6573         if test "x$DIRNAME" = x; then
6574           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6575         fi
6576       else
6577         # Otherwise we believe it is a complete path. Use it as it is.
6578         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
6579 $as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
6580         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
6581 $as_echo_n "checking for DIRNAME... " >&6; }
6582         if test ! -x "$tool_specified"; then
6583           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6584 $as_echo "not found" >&6; }
6585           as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
6586         fi
6587         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6588 $as_echo "$tool_specified" >&6; }
6589       fi
6590     fi
6591   fi
6592 
6593 
6594 
6595   if test "x$DIRNAME" = x; then
6596     as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
6597   fi
6598 
6599 
6600 
6601 
6602 
6603   # Publish this variable in the help.
6604 
6605 
6606   if test "x$ECHO" = x; then
6607     # The variable is not set by user, try to locate tool using the code snippet
6608     for ac_prog in echo
6609 do
6610   # Extract the first word of "$ac_prog", so it can be a program name with args.
6611 set dummy $ac_prog; ac_word=$2
6612 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6613 $as_echo_n "checking for $ac_word... " >&6; }
6614 if ${ac_cv_path_ECHO+:} false; then :
6615   $as_echo_n "(cached) " >&6
6616 else
6617   case $ECHO in
6618   [\\/]* | ?:[\\/]*)
6619   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6620   ;;
6621   *)
6622   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6623 for as_dir in $PATH
6624 do
6625   IFS=$as_save_IFS
6626   test -z "$as_dir" && as_dir=.
6627     for ac_exec_ext in '' $ac_executable_extensions; do
6628   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6629     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6630     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6631     break 2
6632   fi
6633 done
6634   done
6635 IFS=$as_save_IFS
6636 
6637   ;;
6638 esac
6639 fi
6640 ECHO=$ac_cv_path_ECHO
6641 if test -n "$ECHO"; then
6642   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6643 $as_echo "$ECHO" >&6; }
6644 else
6645   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6646 $as_echo "no" >&6; }
6647 fi
6648 
6649 
6650   test -n "$ECHO" && break
6651 done
6652 
6653   else
6654     # The variable is set, but is it from the command line or the environment?
6655 
6656     # Try to remove the string !ECHO! from our list.
6657     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
6658     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6659       # If it failed, the variable was not from the command line. Ignore it,
6660       # but warn the user (except for BASH, which is always set by the calling BASH).
6661       if test "xECHO" != xBASH; then
6662         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
6663 $as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
6664       fi
6665       # Try to locate tool using the code snippet
6666       for ac_prog in echo
6667 do
6668   # Extract the first word of "$ac_prog", so it can be a program name with args.
6669 set dummy $ac_prog; ac_word=$2
6670 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6671 $as_echo_n "checking for $ac_word... " >&6; }
6672 if ${ac_cv_path_ECHO+:} false; then :
6673   $as_echo_n "(cached) " >&6
6674 else
6675   case $ECHO in
6676   [\\/]* | ?:[\\/]*)
6677   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6678   ;;
6679   *)
6680   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6681 for as_dir in $PATH
6682 do
6683   IFS=$as_save_IFS
6684   test -z "$as_dir" && as_dir=.
6685     for ac_exec_ext in '' $ac_executable_extensions; do
6686   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6687     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6688     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6689     break 2
6690   fi
6691 done
6692   done
6693 IFS=$as_save_IFS
6694 
6695   ;;
6696 esac
6697 fi
6698 ECHO=$ac_cv_path_ECHO
6699 if test -n "$ECHO"; then
6700   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6701 $as_echo "$ECHO" >&6; }
6702 else
6703   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6704 $as_echo "no" >&6; }
6705 fi
6706 
6707 
6708   test -n "$ECHO" && break
6709 done
6710 
6711     else
6712       # If it succeeded, then it was overridden by the user. We will use it
6713       # for the tool.
6714 
6715       # First remove it from the list of overridden variables, so we can test
6716       # for unknown variables in the end.
6717       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6718 
6719       # Check if the provided tool contains a complete path.
6720       tool_specified="$ECHO"
6721       tool_basename="${tool_specified##*/}"
6722       if test "x$tool_basename" = "x$tool_specified"; then
6723         # A command without a complete path is provided, search $PATH.
6724         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
6725 $as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
6726         # Extract the first word of "$tool_basename", so it can be a program name with args.
6727 set dummy $tool_basename; ac_word=$2
6728 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6729 $as_echo_n "checking for $ac_word... " >&6; }
6730 if ${ac_cv_path_ECHO+:} false; then :
6731   $as_echo_n "(cached) " >&6
6732 else
6733   case $ECHO in
6734   [\\/]* | ?:[\\/]*)
6735   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6736   ;;
6737   *)
6738   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6739 for as_dir in $PATH
6740 do
6741   IFS=$as_save_IFS
6742   test -z "$as_dir" && as_dir=.
6743     for ac_exec_ext in '' $ac_executable_extensions; do
6744   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6745     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6746     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6747     break 2
6748   fi
6749 done
6750   done
6751 IFS=$as_save_IFS
6752 
6753   ;;
6754 esac
6755 fi
6756 ECHO=$ac_cv_path_ECHO
6757 if test -n "$ECHO"; then
6758   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6759 $as_echo "$ECHO" >&6; }
6760 else
6761   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6762 $as_echo "no" >&6; }
6763 fi
6764 
6765 
6766         if test "x$ECHO" = x; then
6767           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6768         fi
6769       else
6770         # Otherwise we believe it is a complete path. Use it as it is.
6771         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
6772 $as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
6773         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
6774 $as_echo_n "checking for ECHO... " >&6; }
6775         if test ! -x "$tool_specified"; then
6776           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6777 $as_echo "not found" >&6; }
6778           as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
6779         fi
6780         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6781 $as_echo "$tool_specified" >&6; }
6782       fi
6783     fi
6784   fi
6785 
6786 
6787 
6788   if test "x$ECHO" = x; then
6789     as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
6790   fi
6791 
6792 
6793 
6794 
6795 
6796   # Publish this variable in the help.
6797 
6798 
6799   if test "x$EXPR" = x; then
6800     # The variable is not set by user, try to locate tool using the code snippet
6801     for ac_prog in expr
6802 do
6803   # Extract the first word of "$ac_prog", so it can be a program name with args.
6804 set dummy $ac_prog; ac_word=$2
6805 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6806 $as_echo_n "checking for $ac_word... " >&6; }
6807 if ${ac_cv_path_EXPR+:} false; then :
6808   $as_echo_n "(cached) " >&6
6809 else
6810   case $EXPR in
6811   [\\/]* | ?:[\\/]*)
6812   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6813   ;;
6814   *)
6815   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6816 for as_dir in $PATH
6817 do
6818   IFS=$as_save_IFS
6819   test -z "$as_dir" && as_dir=.
6820     for ac_exec_ext in '' $ac_executable_extensions; do
6821   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6822     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6823     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6824     break 2
6825   fi
6826 done
6827   done
6828 IFS=$as_save_IFS
6829 
6830   ;;
6831 esac
6832 fi
6833 EXPR=$ac_cv_path_EXPR
6834 if test -n "$EXPR"; then
6835   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6836 $as_echo "$EXPR" >&6; }
6837 else
6838   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6839 $as_echo "no" >&6; }
6840 fi
6841 
6842 
6843   test -n "$EXPR" && break
6844 done
6845 
6846   else
6847     # The variable is set, but is it from the command line or the environment?
6848 
6849     # Try to remove the string !EXPR! from our list.
6850     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
6851     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6852       # If it failed, the variable was not from the command line. Ignore it,
6853       # but warn the user (except for BASH, which is always set by the calling BASH).
6854       if test "xEXPR" != xBASH; then
6855         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
6856 $as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
6857       fi
6858       # Try to locate tool using the code snippet
6859       for ac_prog in expr
6860 do
6861   # Extract the first word of "$ac_prog", so it can be a program name with args.
6862 set dummy $ac_prog; ac_word=$2
6863 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6864 $as_echo_n "checking for $ac_word... " >&6; }
6865 if ${ac_cv_path_EXPR+:} false; then :
6866   $as_echo_n "(cached) " >&6
6867 else
6868   case $EXPR in
6869   [\\/]* | ?:[\\/]*)
6870   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6871   ;;
6872   *)
6873   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6874 for as_dir in $PATH
6875 do
6876   IFS=$as_save_IFS
6877   test -z "$as_dir" && as_dir=.
6878     for ac_exec_ext in '' $ac_executable_extensions; do
6879   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6880     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6881     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6882     break 2
6883   fi
6884 done
6885   done
6886 IFS=$as_save_IFS
6887 
6888   ;;
6889 esac
6890 fi
6891 EXPR=$ac_cv_path_EXPR
6892 if test -n "$EXPR"; then
6893   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6894 $as_echo "$EXPR" >&6; }
6895 else
6896   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6897 $as_echo "no" >&6; }
6898 fi
6899 
6900 
6901   test -n "$EXPR" && break
6902 done
6903 
6904     else
6905       # If it succeeded, then it was overridden by the user. We will use it
6906       # for the tool.
6907 
6908       # First remove it from the list of overridden variables, so we can test
6909       # for unknown variables in the end.
6910       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6911 
6912       # Check if the provided tool contains a complete path.
6913       tool_specified="$EXPR"
6914       tool_basename="${tool_specified##*/}"
6915       if test "x$tool_basename" = "x$tool_specified"; then
6916         # A command without a complete path is provided, search $PATH.
6917         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
6918 $as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
6919         # Extract the first word of "$tool_basename", so it can be a program name with args.
6920 set dummy $tool_basename; ac_word=$2
6921 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6922 $as_echo_n "checking for $ac_word... " >&6; }
6923 if ${ac_cv_path_EXPR+:} false; then :
6924   $as_echo_n "(cached) " >&6
6925 else
6926   case $EXPR in
6927   [\\/]* | ?:[\\/]*)
6928   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6929   ;;
6930   *)
6931   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6932 for as_dir in $PATH
6933 do
6934   IFS=$as_save_IFS
6935   test -z "$as_dir" && as_dir=.
6936     for ac_exec_ext in '' $ac_executable_extensions; do
6937   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6938     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6939     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6940     break 2
6941   fi
6942 done
6943   done
6944 IFS=$as_save_IFS
6945 
6946   ;;
6947 esac
6948 fi
6949 EXPR=$ac_cv_path_EXPR
6950 if test -n "$EXPR"; then
6951   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6952 $as_echo "$EXPR" >&6; }
6953 else
6954   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6955 $as_echo "no" >&6; }
6956 fi
6957 
6958 
6959         if test "x$EXPR" = x; then
6960           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6961         fi
6962       else
6963         # Otherwise we believe it is a complete path. Use it as it is.
6964         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
6965 $as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
6966         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
6967 $as_echo_n "checking for EXPR... " >&6; }
6968         if test ! -x "$tool_specified"; then
6969           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6970 $as_echo "not found" >&6; }
6971           as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
6972         fi
6973         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6974 $as_echo "$tool_specified" >&6; }
6975       fi
6976     fi
6977   fi
6978 
6979 
6980 
6981   if test "x$EXPR" = x; then
6982     as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
6983   fi
6984 
6985 
6986 
6987 
6988 
6989   # Publish this variable in the help.
6990 
6991 
6992   if test "x$FILE" = x; then
6993     # The variable is not set by user, try to locate tool using the code snippet
6994     for ac_prog in file
6995 do
6996   # Extract the first word of "$ac_prog", so it can be a program name with args.
6997 set dummy $ac_prog; ac_word=$2
6998 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6999 $as_echo_n "checking for $ac_word... " >&6; }
7000 if ${ac_cv_path_FILE+:} false; then :
7001   $as_echo_n "(cached) " >&6
7002 else
7003   case $FILE in
7004   [\\/]* | ?:[\\/]*)
7005   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7006   ;;
7007   *)
7008   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7009 for as_dir in $PATH
7010 do
7011   IFS=$as_save_IFS
7012   test -z "$as_dir" && as_dir=.
7013     for ac_exec_ext in '' $ac_executable_extensions; do
7014   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7015     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7016     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7017     break 2
7018   fi
7019 done
7020   done
7021 IFS=$as_save_IFS
7022 
7023   ;;
7024 esac
7025 fi
7026 FILE=$ac_cv_path_FILE
7027 if test -n "$FILE"; then
7028   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7029 $as_echo "$FILE" >&6; }
7030 else
7031   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7032 $as_echo "no" >&6; }
7033 fi
7034 
7035 
7036   test -n "$FILE" && break
7037 done
7038 
7039   else
7040     # The variable is set, but is it from the command line or the environment?
7041 
7042     # Try to remove the string !FILE! from our list.
7043     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
7044     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7045       # If it failed, the variable was not from the command line. Ignore it,
7046       # but warn the user (except for BASH, which is always set by the calling BASH).
7047       if test "xFILE" != xBASH; then
7048         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
7049 $as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
7050       fi
7051       # Try to locate tool using the code snippet
7052       for ac_prog in file
7053 do
7054   # Extract the first word of "$ac_prog", so it can be a program name with args.
7055 set dummy $ac_prog; ac_word=$2
7056 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7057 $as_echo_n "checking for $ac_word... " >&6; }
7058 if ${ac_cv_path_FILE+:} false; then :
7059   $as_echo_n "(cached) " >&6
7060 else
7061   case $FILE in
7062   [\\/]* | ?:[\\/]*)
7063   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7064   ;;
7065   *)
7066   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7067 for as_dir in $PATH
7068 do
7069   IFS=$as_save_IFS
7070   test -z "$as_dir" && as_dir=.
7071     for ac_exec_ext in '' $ac_executable_extensions; do
7072   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7073     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7074     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7075     break 2
7076   fi
7077 done
7078   done
7079 IFS=$as_save_IFS
7080 
7081   ;;
7082 esac
7083 fi
7084 FILE=$ac_cv_path_FILE
7085 if test -n "$FILE"; then
7086   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7087 $as_echo "$FILE" >&6; }
7088 else
7089   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7090 $as_echo "no" >&6; }
7091 fi
7092 
7093 
7094   test -n "$FILE" && break
7095 done
7096 
7097     else
7098       # If it succeeded, then it was overridden by the user. We will use it
7099       # for the tool.
7100 
7101       # First remove it from the list of overridden variables, so we can test
7102       # for unknown variables in the end.
7103       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7104 
7105       # Check if the provided tool contains a complete path.
7106       tool_specified="$FILE"
7107       tool_basename="${tool_specified##*/}"
7108       if test "x$tool_basename" = "x$tool_specified"; then
7109         # A command without a complete path is provided, search $PATH.
7110         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
7111 $as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
7112         # Extract the first word of "$tool_basename", so it can be a program name with args.
7113 set dummy $tool_basename; ac_word=$2
7114 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7115 $as_echo_n "checking for $ac_word... " >&6; }
7116 if ${ac_cv_path_FILE+:} false; then :
7117   $as_echo_n "(cached) " >&6
7118 else
7119   case $FILE in
7120   [\\/]* | ?:[\\/]*)
7121   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7122   ;;
7123   *)
7124   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7125 for as_dir in $PATH
7126 do
7127   IFS=$as_save_IFS
7128   test -z "$as_dir" && as_dir=.
7129     for ac_exec_ext in '' $ac_executable_extensions; do
7130   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7131     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7132     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7133     break 2
7134   fi
7135 done
7136   done
7137 IFS=$as_save_IFS
7138 
7139   ;;
7140 esac
7141 fi
7142 FILE=$ac_cv_path_FILE
7143 if test -n "$FILE"; then
7144   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7145 $as_echo "$FILE" >&6; }
7146 else
7147   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7148 $as_echo "no" >&6; }
7149 fi
7150 
7151 
7152         if test "x$FILE" = x; then
7153           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7154         fi
7155       else
7156         # Otherwise we believe it is a complete path. Use it as it is.
7157         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
7158 $as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
7159         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7160 $as_echo_n "checking for FILE... " >&6; }
7161         if test ! -x "$tool_specified"; then
7162           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7163 $as_echo "not found" >&6; }
7164           as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
7165         fi
7166         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7167 $as_echo "$tool_specified" >&6; }
7168       fi
7169     fi
7170   fi
7171 
7172 
7173 
7174   if test "x$FILE" = x; then
7175     as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
7176   fi
7177 
7178 
7179 
7180 
7181 
7182   # Publish this variable in the help.
7183 
7184 
7185   if test "x$FIND" = x; then
7186     # The variable is not set by user, try to locate tool using the code snippet
7187     for ac_prog in find
7188 do
7189   # Extract the first word of "$ac_prog", so it can be a program name with args.
7190 set dummy $ac_prog; ac_word=$2
7191 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7192 $as_echo_n "checking for $ac_word... " >&6; }
7193 if ${ac_cv_path_FIND+:} false; then :
7194   $as_echo_n "(cached) " >&6
7195 else
7196   case $FIND in
7197   [\\/]* | ?:[\\/]*)
7198   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7199   ;;
7200   *)
7201   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7202 for as_dir in $PATH
7203 do
7204   IFS=$as_save_IFS
7205   test -z "$as_dir" && as_dir=.
7206     for ac_exec_ext in '' $ac_executable_extensions; do
7207   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7208     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7209     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7210     break 2
7211   fi
7212 done
7213   done
7214 IFS=$as_save_IFS
7215 
7216   ;;
7217 esac
7218 fi
7219 FIND=$ac_cv_path_FIND
7220 if test -n "$FIND"; then
7221   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7222 $as_echo "$FIND" >&6; }
7223 else
7224   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7225 $as_echo "no" >&6; }
7226 fi
7227 
7228 
7229   test -n "$FIND" && break
7230 done
7231 
7232   else
7233     # The variable is set, but is it from the command line or the environment?
7234 
7235     # Try to remove the string !FIND! from our list.
7236     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
7237     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7238       # If it failed, the variable was not from the command line. Ignore it,
7239       # but warn the user (except for BASH, which is always set by the calling BASH).
7240       if test "xFIND" != xBASH; then
7241         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
7242 $as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
7243       fi
7244       # Try to locate tool using the code snippet
7245       for ac_prog in find
7246 do
7247   # Extract the first word of "$ac_prog", so it can be a program name with args.
7248 set dummy $ac_prog; ac_word=$2
7249 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7250 $as_echo_n "checking for $ac_word... " >&6; }
7251 if ${ac_cv_path_FIND+:} false; then :
7252   $as_echo_n "(cached) " >&6
7253 else
7254   case $FIND in
7255   [\\/]* | ?:[\\/]*)
7256   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7257   ;;
7258   *)
7259   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7260 for as_dir in $PATH
7261 do
7262   IFS=$as_save_IFS
7263   test -z "$as_dir" && as_dir=.
7264     for ac_exec_ext in '' $ac_executable_extensions; do
7265   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7266     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7267     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7268     break 2
7269   fi
7270 done
7271   done
7272 IFS=$as_save_IFS
7273 
7274   ;;
7275 esac
7276 fi
7277 FIND=$ac_cv_path_FIND
7278 if test -n "$FIND"; then
7279   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7280 $as_echo "$FIND" >&6; }
7281 else
7282   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7283 $as_echo "no" >&6; }
7284 fi
7285 
7286 
7287   test -n "$FIND" && break
7288 done
7289 
7290     else
7291       # If it succeeded, then it was overridden by the user. We will use it
7292       # for the tool.
7293 
7294       # First remove it from the list of overridden variables, so we can test
7295       # for unknown variables in the end.
7296       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7297 
7298       # Check if the provided tool contains a complete path.
7299       tool_specified="$FIND"
7300       tool_basename="${tool_specified##*/}"
7301       if test "x$tool_basename" = "x$tool_specified"; then
7302         # A command without a complete path is provided, search $PATH.
7303         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
7304 $as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
7305         # Extract the first word of "$tool_basename", so it can be a program name with args.
7306 set dummy $tool_basename; ac_word=$2
7307 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7308 $as_echo_n "checking for $ac_word... " >&6; }
7309 if ${ac_cv_path_FIND+:} false; then :
7310   $as_echo_n "(cached) " >&6
7311 else
7312   case $FIND in
7313   [\\/]* | ?:[\\/]*)
7314   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7315   ;;
7316   *)
7317   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7318 for as_dir in $PATH
7319 do
7320   IFS=$as_save_IFS
7321   test -z "$as_dir" && as_dir=.
7322     for ac_exec_ext in '' $ac_executable_extensions; do
7323   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7324     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7325     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7326     break 2
7327   fi
7328 done
7329   done
7330 IFS=$as_save_IFS
7331 
7332   ;;
7333 esac
7334 fi
7335 FIND=$ac_cv_path_FIND
7336 if test -n "$FIND"; then
7337   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7338 $as_echo "$FIND" >&6; }
7339 else
7340   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7341 $as_echo "no" >&6; }
7342 fi
7343 
7344 
7345         if test "x$FIND" = x; then
7346           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7347         fi
7348       else
7349         # Otherwise we believe it is a complete path. Use it as it is.
7350         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
7351 $as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
7352         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
7353 $as_echo_n "checking for FIND... " >&6; }
7354         if test ! -x "$tool_specified"; then
7355           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7356 $as_echo "not found" >&6; }
7357           as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
7358         fi
7359         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7360 $as_echo "$tool_specified" >&6; }
7361       fi
7362     fi
7363   fi
7364 
7365 
7366 
7367   if test "x$FIND" = x; then
7368     as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
7369   fi
7370 
7371 
7372 
7373 
7374 
7375   # Publish this variable in the help.
7376 
7377 
7378   if test "x$HEAD" = x; then
7379     # The variable is not set by user, try to locate tool using the code snippet
7380     for ac_prog in head
7381 do
7382   # Extract the first word of "$ac_prog", so it can be a program name with args.
7383 set dummy $ac_prog; ac_word=$2
7384 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7385 $as_echo_n "checking for $ac_word... " >&6; }
7386 if ${ac_cv_path_HEAD+:} false; then :
7387   $as_echo_n "(cached) " >&6
7388 else
7389   case $HEAD in
7390   [\\/]* | ?:[\\/]*)
7391   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7392   ;;
7393   *)
7394   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7395 for as_dir in $PATH
7396 do
7397   IFS=$as_save_IFS
7398   test -z "$as_dir" && as_dir=.
7399     for ac_exec_ext in '' $ac_executable_extensions; do
7400   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7401     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7402     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7403     break 2
7404   fi
7405 done
7406   done
7407 IFS=$as_save_IFS
7408 
7409   ;;
7410 esac
7411 fi
7412 HEAD=$ac_cv_path_HEAD
7413 if test -n "$HEAD"; then
7414   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7415 $as_echo "$HEAD" >&6; }
7416 else
7417   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7418 $as_echo "no" >&6; }
7419 fi
7420 
7421 
7422   test -n "$HEAD" && break
7423 done
7424 
7425   else
7426     # The variable is set, but is it from the command line or the environment?
7427 
7428     # Try to remove the string !HEAD! from our list.
7429     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
7430     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7431       # If it failed, the variable was not from the command line. Ignore it,
7432       # but warn the user (except for BASH, which is always set by the calling BASH).
7433       if test "xHEAD" != xBASH; then
7434         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
7435 $as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
7436       fi
7437       # Try to locate tool using the code snippet
7438       for ac_prog in head
7439 do
7440   # Extract the first word of "$ac_prog", so it can be a program name with args.
7441 set dummy $ac_prog; ac_word=$2
7442 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7443 $as_echo_n "checking for $ac_word... " >&6; }
7444 if ${ac_cv_path_HEAD+:} false; then :
7445   $as_echo_n "(cached) " >&6
7446 else
7447   case $HEAD in
7448   [\\/]* | ?:[\\/]*)
7449   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7450   ;;
7451   *)
7452   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7453 for as_dir in $PATH
7454 do
7455   IFS=$as_save_IFS
7456   test -z "$as_dir" && as_dir=.
7457     for ac_exec_ext in '' $ac_executable_extensions; do
7458   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7459     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7460     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7461     break 2
7462   fi
7463 done
7464   done
7465 IFS=$as_save_IFS
7466 
7467   ;;
7468 esac
7469 fi
7470 HEAD=$ac_cv_path_HEAD
7471 if test -n "$HEAD"; then
7472   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7473 $as_echo "$HEAD" >&6; }
7474 else
7475   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7476 $as_echo "no" >&6; }
7477 fi
7478 
7479 
7480   test -n "$HEAD" && break
7481 done
7482 
7483     else
7484       # If it succeeded, then it was overridden by the user. We will use it
7485       # for the tool.
7486 
7487       # First remove it from the list of overridden variables, so we can test
7488       # for unknown variables in the end.
7489       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7490 
7491       # Check if the provided tool contains a complete path.
7492       tool_specified="$HEAD"
7493       tool_basename="${tool_specified##*/}"
7494       if test "x$tool_basename" = "x$tool_specified"; then
7495         # A command without a complete path is provided, search $PATH.
7496         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
7497 $as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
7498         # Extract the first word of "$tool_basename", so it can be a program name with args.
7499 set dummy $tool_basename; ac_word=$2
7500 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7501 $as_echo_n "checking for $ac_word... " >&6; }
7502 if ${ac_cv_path_HEAD+:} false; then :
7503   $as_echo_n "(cached) " >&6
7504 else
7505   case $HEAD in
7506   [\\/]* | ?:[\\/]*)
7507   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7508   ;;
7509   *)
7510   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7511 for as_dir in $PATH
7512 do
7513   IFS=$as_save_IFS
7514   test -z "$as_dir" && as_dir=.
7515     for ac_exec_ext in '' $ac_executable_extensions; do
7516   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7517     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7518     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7519     break 2
7520   fi
7521 done
7522   done
7523 IFS=$as_save_IFS
7524 
7525   ;;
7526 esac
7527 fi
7528 HEAD=$ac_cv_path_HEAD
7529 if test -n "$HEAD"; then
7530   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7531 $as_echo "$HEAD" >&6; }
7532 else
7533   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7534 $as_echo "no" >&6; }
7535 fi
7536 
7537 
7538         if test "x$HEAD" = x; then
7539           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7540         fi
7541       else
7542         # Otherwise we believe it is a complete path. Use it as it is.
7543         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
7544 $as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
7545         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
7546 $as_echo_n "checking for HEAD... " >&6; }
7547         if test ! -x "$tool_specified"; then
7548           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7549 $as_echo "not found" >&6; }
7550           as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
7551         fi
7552         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7553 $as_echo "$tool_specified" >&6; }
7554       fi
7555     fi
7556   fi
7557 
7558 
7559 
7560   if test "x$HEAD" = x; then
7561     as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
7562   fi
7563 
7564 
7565 
7566 
7567 
7568   # Publish this variable in the help.
7569 
7570 
7571   if test "x$LN" = x; then
7572     # The variable is not set by user, try to locate tool using the code snippet
7573     for ac_prog in ln
7574 do
7575   # Extract the first word of "$ac_prog", so it can be a program name with args.
7576 set dummy $ac_prog; ac_word=$2
7577 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7578 $as_echo_n "checking for $ac_word... " >&6; }
7579 if ${ac_cv_path_LN+:} false; then :
7580   $as_echo_n "(cached) " >&6
7581 else
7582   case $LN in
7583   [\\/]* | ?:[\\/]*)
7584   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7585   ;;
7586   *)
7587   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7588 for as_dir in $PATH
7589 do
7590   IFS=$as_save_IFS
7591   test -z "$as_dir" && as_dir=.
7592     for ac_exec_ext in '' $ac_executable_extensions; do
7593   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7594     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7595     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7596     break 2
7597   fi
7598 done
7599   done
7600 IFS=$as_save_IFS
7601 
7602   ;;
7603 esac
7604 fi
7605 LN=$ac_cv_path_LN
7606 if test -n "$LN"; then
7607   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7608 $as_echo "$LN" >&6; }
7609 else
7610   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7611 $as_echo "no" >&6; }
7612 fi
7613 
7614 
7615   test -n "$LN" && break
7616 done
7617 
7618   else
7619     # The variable is set, but is it from the command line or the environment?
7620 
7621     # Try to remove the string !LN! from our list.
7622     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
7623     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7624       # If it failed, the variable was not from the command line. Ignore it,
7625       # but warn the user (except for BASH, which is always set by the calling BASH).
7626       if test "xLN" != xBASH; then
7627         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
7628 $as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
7629       fi
7630       # Try to locate tool using the code snippet
7631       for ac_prog in ln
7632 do
7633   # Extract the first word of "$ac_prog", so it can be a program name with args.
7634 set dummy $ac_prog; ac_word=$2
7635 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7636 $as_echo_n "checking for $ac_word... " >&6; }
7637 if ${ac_cv_path_LN+:} false; then :
7638   $as_echo_n "(cached) " >&6
7639 else
7640   case $LN in
7641   [\\/]* | ?:[\\/]*)
7642   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7643   ;;
7644   *)
7645   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7646 for as_dir in $PATH
7647 do
7648   IFS=$as_save_IFS
7649   test -z "$as_dir" && as_dir=.
7650     for ac_exec_ext in '' $ac_executable_extensions; do
7651   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7652     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7653     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7654     break 2
7655   fi
7656 done
7657   done
7658 IFS=$as_save_IFS
7659 
7660   ;;
7661 esac
7662 fi
7663 LN=$ac_cv_path_LN
7664 if test -n "$LN"; then
7665   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7666 $as_echo "$LN" >&6; }
7667 else
7668   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7669 $as_echo "no" >&6; }
7670 fi
7671 
7672 
7673   test -n "$LN" && break
7674 done
7675 
7676     else
7677       # If it succeeded, then it was overridden by the user. We will use it
7678       # for the tool.
7679 
7680       # First remove it from the list of overridden variables, so we can test
7681       # for unknown variables in the end.
7682       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7683 
7684       # Check if the provided tool contains a complete path.
7685       tool_specified="$LN"
7686       tool_basename="${tool_specified##*/}"
7687       if test "x$tool_basename" = "x$tool_specified"; then
7688         # A command without a complete path is provided, search $PATH.
7689         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
7690 $as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
7691         # Extract the first word of "$tool_basename", so it can be a program name with args.
7692 set dummy $tool_basename; ac_word=$2
7693 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7694 $as_echo_n "checking for $ac_word... " >&6; }
7695 if ${ac_cv_path_LN+:} false; then :
7696   $as_echo_n "(cached) " >&6
7697 else
7698   case $LN in
7699   [\\/]* | ?:[\\/]*)
7700   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7701   ;;
7702   *)
7703   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7704 for as_dir in $PATH
7705 do
7706   IFS=$as_save_IFS
7707   test -z "$as_dir" && as_dir=.
7708     for ac_exec_ext in '' $ac_executable_extensions; do
7709   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7710     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7711     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7712     break 2
7713   fi
7714 done
7715   done
7716 IFS=$as_save_IFS
7717 
7718   ;;
7719 esac
7720 fi
7721 LN=$ac_cv_path_LN
7722 if test -n "$LN"; then
7723   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7724 $as_echo "$LN" >&6; }
7725 else
7726   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7727 $as_echo "no" >&6; }
7728 fi
7729 
7730 
7731         if test "x$LN" = x; then
7732           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7733         fi
7734       else
7735         # Otherwise we believe it is a complete path. Use it as it is.
7736         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
7737 $as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
7738         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
7739 $as_echo_n "checking for LN... " >&6; }
7740         if test ! -x "$tool_specified"; then
7741           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7742 $as_echo "not found" >&6; }
7743           as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
7744         fi
7745         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7746 $as_echo "$tool_specified" >&6; }
7747       fi
7748     fi
7749   fi
7750 
7751 
7752 
7753   if test "x$LN" = x; then
7754     as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
7755   fi
7756 
7757 
7758 
7759 
7760 
7761   # Publish this variable in the help.
7762 
7763 
7764   if test "x$LS" = x; then
7765     # The variable is not set by user, try to locate tool using the code snippet
7766     for ac_prog in ls
7767 do
7768   # Extract the first word of "$ac_prog", so it can be a program name with args.
7769 set dummy $ac_prog; ac_word=$2
7770 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7771 $as_echo_n "checking for $ac_word... " >&6; }
7772 if ${ac_cv_path_LS+:} false; then :
7773   $as_echo_n "(cached) " >&6
7774 else
7775   case $LS in
7776   [\\/]* | ?:[\\/]*)
7777   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7778   ;;
7779   *)
7780   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7781 for as_dir in $PATH
7782 do
7783   IFS=$as_save_IFS
7784   test -z "$as_dir" && as_dir=.
7785     for ac_exec_ext in '' $ac_executable_extensions; do
7786   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7787     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7788     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7789     break 2
7790   fi
7791 done
7792   done
7793 IFS=$as_save_IFS
7794 
7795   ;;
7796 esac
7797 fi
7798 LS=$ac_cv_path_LS
7799 if test -n "$LS"; then
7800   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7801 $as_echo "$LS" >&6; }
7802 else
7803   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7804 $as_echo "no" >&6; }
7805 fi
7806 
7807 
7808   test -n "$LS" && break
7809 done
7810 
7811   else
7812     # The variable is set, but is it from the command line or the environment?
7813 
7814     # Try to remove the string !LS! from our list.
7815     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
7816     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7817       # If it failed, the variable was not from the command line. Ignore it,
7818       # but warn the user (except for BASH, which is always set by the calling BASH).
7819       if test "xLS" != xBASH; then
7820         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
7821 $as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
7822       fi
7823       # Try to locate tool using the code snippet
7824       for ac_prog in ls
7825 do
7826   # Extract the first word of "$ac_prog", so it can be a program name with args.
7827 set dummy $ac_prog; ac_word=$2
7828 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7829 $as_echo_n "checking for $ac_word... " >&6; }
7830 if ${ac_cv_path_LS+:} false; then :
7831   $as_echo_n "(cached) " >&6
7832 else
7833   case $LS in
7834   [\\/]* | ?:[\\/]*)
7835   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7836   ;;
7837   *)
7838   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7839 for as_dir in $PATH
7840 do
7841   IFS=$as_save_IFS
7842   test -z "$as_dir" && as_dir=.
7843     for ac_exec_ext in '' $ac_executable_extensions; do
7844   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7845     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7846     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7847     break 2
7848   fi
7849 done
7850   done
7851 IFS=$as_save_IFS
7852 
7853   ;;
7854 esac
7855 fi
7856 LS=$ac_cv_path_LS
7857 if test -n "$LS"; then
7858   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7859 $as_echo "$LS" >&6; }
7860 else
7861   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7862 $as_echo "no" >&6; }
7863 fi
7864 
7865 
7866   test -n "$LS" && break
7867 done
7868 
7869     else
7870       # If it succeeded, then it was overridden by the user. We will use it
7871       # for the tool.
7872 
7873       # First remove it from the list of overridden variables, so we can test
7874       # for unknown variables in the end.
7875       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7876 
7877       # Check if the provided tool contains a complete path.
7878       tool_specified="$LS"
7879       tool_basename="${tool_specified##*/}"
7880       if test "x$tool_basename" = "x$tool_specified"; then
7881         # A command without a complete path is provided, search $PATH.
7882         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
7883 $as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
7884         # Extract the first word of "$tool_basename", so it can be a program name with args.
7885 set dummy $tool_basename; ac_word=$2
7886 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7887 $as_echo_n "checking for $ac_word... " >&6; }
7888 if ${ac_cv_path_LS+:} false; then :
7889   $as_echo_n "(cached) " >&6
7890 else
7891   case $LS in
7892   [\\/]* | ?:[\\/]*)
7893   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7894   ;;
7895   *)
7896   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7897 for as_dir in $PATH
7898 do
7899   IFS=$as_save_IFS
7900   test -z "$as_dir" && as_dir=.
7901     for ac_exec_ext in '' $ac_executable_extensions; do
7902   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7903     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7904     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7905     break 2
7906   fi
7907 done
7908   done
7909 IFS=$as_save_IFS
7910 
7911   ;;
7912 esac
7913 fi
7914 LS=$ac_cv_path_LS
7915 if test -n "$LS"; then
7916   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7917 $as_echo "$LS" >&6; }
7918 else
7919   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7920 $as_echo "no" >&6; }
7921 fi
7922 
7923 
7924         if test "x$LS" = x; then
7925           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7926         fi
7927       else
7928         # Otherwise we believe it is a complete path. Use it as it is.
7929         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
7930 $as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
7931         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
7932 $as_echo_n "checking for LS... " >&6; }
7933         if test ! -x "$tool_specified"; then
7934           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7935 $as_echo "not found" >&6; }
7936           as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
7937         fi
7938         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7939 $as_echo "$tool_specified" >&6; }
7940       fi
7941     fi
7942   fi
7943 
7944 
7945 
7946   if test "x$LS" = x; then
7947     as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
7948   fi
7949 
7950 
7951 
7952 
7953 
7954   # Publish this variable in the help.
7955 
7956 
7957   if test "x$MKDIR" = x; then
7958     # The variable is not set by user, try to locate tool using the code snippet
7959     for ac_prog in mkdir
7960 do
7961   # Extract the first word of "$ac_prog", so it can be a program name with args.
7962 set dummy $ac_prog; ac_word=$2
7963 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7964 $as_echo_n "checking for $ac_word... " >&6; }
7965 if ${ac_cv_path_MKDIR+:} false; then :
7966   $as_echo_n "(cached) " >&6
7967 else
7968   case $MKDIR in
7969   [\\/]* | ?:[\\/]*)
7970   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7971   ;;
7972   *)
7973   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7974 for as_dir in $PATH
7975 do
7976   IFS=$as_save_IFS
7977   test -z "$as_dir" && as_dir=.
7978     for ac_exec_ext in '' $ac_executable_extensions; do
7979   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7980     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7981     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7982     break 2
7983   fi
7984 done
7985   done
7986 IFS=$as_save_IFS
7987 
7988   ;;
7989 esac
7990 fi
7991 MKDIR=$ac_cv_path_MKDIR
7992 if test -n "$MKDIR"; then
7993   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
7994 $as_echo "$MKDIR" >&6; }
7995 else
7996   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7997 $as_echo "no" >&6; }
7998 fi
7999 
8000 
8001   test -n "$MKDIR" && break
8002 done
8003 
8004   else
8005     # The variable is set, but is it from the command line or the environment?
8006 
8007     # Try to remove the string !MKDIR! from our list.
8008     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
8009     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8010       # If it failed, the variable was not from the command line. Ignore it,
8011       # but warn the user (except for BASH, which is always set by the calling BASH).
8012       if test "xMKDIR" != xBASH; then
8013         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
8014 $as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
8015       fi
8016       # Try to locate tool using the code snippet
8017       for ac_prog in mkdir
8018 do
8019   # Extract the first word of "$ac_prog", so it can be a program name with args.
8020 set dummy $ac_prog; ac_word=$2
8021 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8022 $as_echo_n "checking for $ac_word... " >&6; }
8023 if ${ac_cv_path_MKDIR+:} false; then :
8024   $as_echo_n "(cached) " >&6
8025 else
8026   case $MKDIR in
8027   [\\/]* | ?:[\\/]*)
8028   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8029   ;;
8030   *)
8031   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8032 for as_dir in $PATH
8033 do
8034   IFS=$as_save_IFS
8035   test -z "$as_dir" && as_dir=.
8036     for ac_exec_ext in '' $ac_executable_extensions; do
8037   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8038     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8039     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8040     break 2
8041   fi
8042 done
8043   done
8044 IFS=$as_save_IFS
8045 
8046   ;;
8047 esac
8048 fi
8049 MKDIR=$ac_cv_path_MKDIR
8050 if test -n "$MKDIR"; then
8051   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8052 $as_echo "$MKDIR" >&6; }
8053 else
8054   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8055 $as_echo "no" >&6; }
8056 fi
8057 
8058 
8059   test -n "$MKDIR" && break
8060 done
8061 
8062     else
8063       # If it succeeded, then it was overridden by the user. We will use it
8064       # for the tool.
8065 
8066       # First remove it from the list of overridden variables, so we can test
8067       # for unknown variables in the end.
8068       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8069 
8070       # Check if the provided tool contains a complete path.
8071       tool_specified="$MKDIR"
8072       tool_basename="${tool_specified##*/}"
8073       if test "x$tool_basename" = "x$tool_specified"; then
8074         # A command without a complete path is provided, search $PATH.
8075         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
8076 $as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
8077         # Extract the first word of "$tool_basename", so it can be a program name with args.
8078 set dummy $tool_basename; ac_word=$2
8079 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8080 $as_echo_n "checking for $ac_word... " >&6; }
8081 if ${ac_cv_path_MKDIR+:} false; then :
8082   $as_echo_n "(cached) " >&6
8083 else
8084   case $MKDIR in
8085   [\\/]* | ?:[\\/]*)
8086   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8087   ;;
8088   *)
8089   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8090 for as_dir in $PATH
8091 do
8092   IFS=$as_save_IFS
8093   test -z "$as_dir" && as_dir=.
8094     for ac_exec_ext in '' $ac_executable_extensions; do
8095   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8096     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8097     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8098     break 2
8099   fi
8100 done
8101   done
8102 IFS=$as_save_IFS
8103 
8104   ;;
8105 esac
8106 fi
8107 MKDIR=$ac_cv_path_MKDIR
8108 if test -n "$MKDIR"; then
8109   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8110 $as_echo "$MKDIR" >&6; }
8111 else
8112   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8113 $as_echo "no" >&6; }
8114 fi
8115 
8116 
8117         if test "x$MKDIR" = x; then
8118           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8119         fi
8120       else
8121         # Otherwise we believe it is a complete path. Use it as it is.
8122         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
8123 $as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
8124         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
8125 $as_echo_n "checking for MKDIR... " >&6; }
8126         if test ! -x "$tool_specified"; then
8127           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8128 $as_echo "not found" >&6; }
8129           as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
8130         fi
8131         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8132 $as_echo "$tool_specified" >&6; }
8133       fi
8134     fi
8135   fi
8136 
8137 
8138 
8139   if test "x$MKDIR" = x; then
8140     as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
8141   fi
8142 
8143 
8144 
8145 
8146 
8147   # Publish this variable in the help.
8148 
8149 
8150   if test "x$MKTEMP" = x; then
8151     # The variable is not set by user, try to locate tool using the code snippet
8152     for ac_prog in mktemp
8153 do
8154   # Extract the first word of "$ac_prog", so it can be a program name with args.
8155 set dummy $ac_prog; ac_word=$2
8156 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8157 $as_echo_n "checking for $ac_word... " >&6; }
8158 if ${ac_cv_path_MKTEMP+:} false; then :
8159   $as_echo_n "(cached) " >&6
8160 else
8161   case $MKTEMP in
8162   [\\/]* | ?:[\\/]*)
8163   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8164   ;;
8165   *)
8166   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8167 for as_dir in $PATH
8168 do
8169   IFS=$as_save_IFS
8170   test -z "$as_dir" && as_dir=.
8171     for ac_exec_ext in '' $ac_executable_extensions; do
8172   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8173     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8174     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8175     break 2
8176   fi
8177 done
8178   done
8179 IFS=$as_save_IFS
8180 
8181   ;;
8182 esac
8183 fi
8184 MKTEMP=$ac_cv_path_MKTEMP
8185 if test -n "$MKTEMP"; then
8186   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8187 $as_echo "$MKTEMP" >&6; }
8188 else
8189   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8190 $as_echo "no" >&6; }
8191 fi
8192 
8193 
8194   test -n "$MKTEMP" && break
8195 done
8196 
8197   else
8198     # The variable is set, but is it from the command line or the environment?
8199 
8200     # Try to remove the string !MKTEMP! from our list.
8201     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
8202     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8203       # If it failed, the variable was not from the command line. Ignore it,
8204       # but warn the user (except for BASH, which is always set by the calling BASH).
8205       if test "xMKTEMP" != xBASH; then
8206         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
8207 $as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
8208       fi
8209       # Try to locate tool using the code snippet
8210       for ac_prog in mktemp
8211 do
8212   # Extract the first word of "$ac_prog", so it can be a program name with args.
8213 set dummy $ac_prog; ac_word=$2
8214 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8215 $as_echo_n "checking for $ac_word... " >&6; }
8216 if ${ac_cv_path_MKTEMP+:} false; then :
8217   $as_echo_n "(cached) " >&6
8218 else
8219   case $MKTEMP in
8220   [\\/]* | ?:[\\/]*)
8221   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8222   ;;
8223   *)
8224   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8225 for as_dir in $PATH
8226 do
8227   IFS=$as_save_IFS
8228   test -z "$as_dir" && as_dir=.
8229     for ac_exec_ext in '' $ac_executable_extensions; do
8230   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8231     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8232     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8233     break 2
8234   fi
8235 done
8236   done
8237 IFS=$as_save_IFS
8238 
8239   ;;
8240 esac
8241 fi
8242 MKTEMP=$ac_cv_path_MKTEMP
8243 if test -n "$MKTEMP"; then
8244   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8245 $as_echo "$MKTEMP" >&6; }
8246 else
8247   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8248 $as_echo "no" >&6; }
8249 fi
8250 
8251 
8252   test -n "$MKTEMP" && break
8253 done
8254 
8255     else
8256       # If it succeeded, then it was overridden by the user. We will use it
8257       # for the tool.
8258 
8259       # First remove it from the list of overridden variables, so we can test
8260       # for unknown variables in the end.
8261       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8262 
8263       # Check if the provided tool contains a complete path.
8264       tool_specified="$MKTEMP"
8265       tool_basename="${tool_specified##*/}"
8266       if test "x$tool_basename" = "x$tool_specified"; then
8267         # A command without a complete path is provided, search $PATH.
8268         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
8269 $as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
8270         # Extract the first word of "$tool_basename", so it can be a program name with args.
8271 set dummy $tool_basename; ac_word=$2
8272 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8273 $as_echo_n "checking for $ac_word... " >&6; }
8274 if ${ac_cv_path_MKTEMP+:} false; then :
8275   $as_echo_n "(cached) " >&6
8276 else
8277   case $MKTEMP in
8278   [\\/]* | ?:[\\/]*)
8279   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8280   ;;
8281   *)
8282   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8283 for as_dir in $PATH
8284 do
8285   IFS=$as_save_IFS
8286   test -z "$as_dir" && as_dir=.
8287     for ac_exec_ext in '' $ac_executable_extensions; do
8288   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8289     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8290     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8291     break 2
8292   fi
8293 done
8294   done
8295 IFS=$as_save_IFS
8296 
8297   ;;
8298 esac
8299 fi
8300 MKTEMP=$ac_cv_path_MKTEMP
8301 if test -n "$MKTEMP"; then
8302   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8303 $as_echo "$MKTEMP" >&6; }
8304 else
8305   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8306 $as_echo "no" >&6; }
8307 fi
8308 
8309 
8310         if test "x$MKTEMP" = x; then
8311           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8312         fi
8313       else
8314         # Otherwise we believe it is a complete path. Use it as it is.
8315         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
8316 $as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
8317         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
8318 $as_echo_n "checking for MKTEMP... " >&6; }
8319         if test ! -x "$tool_specified"; then
8320           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8321 $as_echo "not found" >&6; }
8322           as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
8323         fi
8324         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8325 $as_echo "$tool_specified" >&6; }
8326       fi
8327     fi
8328   fi
8329 
8330 
8331 
8332   if test "x$MKTEMP" = x; then
8333     as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
8334   fi
8335 
8336 
8337 
8338 
8339 
8340   # Publish this variable in the help.
8341 
8342 
8343   if test "x$MV" = x; then
8344     # The variable is not set by user, try to locate tool using the code snippet
8345     for ac_prog in mv
8346 do
8347   # Extract the first word of "$ac_prog", so it can be a program name with args.
8348 set dummy $ac_prog; ac_word=$2
8349 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8350 $as_echo_n "checking for $ac_word... " >&6; }
8351 if ${ac_cv_path_MV+:} false; then :
8352   $as_echo_n "(cached) " >&6
8353 else
8354   case $MV in
8355   [\\/]* | ?:[\\/]*)
8356   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8357   ;;
8358   *)
8359   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8360 for as_dir in $PATH
8361 do
8362   IFS=$as_save_IFS
8363   test -z "$as_dir" && as_dir=.
8364     for ac_exec_ext in '' $ac_executable_extensions; do
8365   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8366     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8367     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8368     break 2
8369   fi
8370 done
8371   done
8372 IFS=$as_save_IFS
8373 
8374   ;;
8375 esac
8376 fi
8377 MV=$ac_cv_path_MV
8378 if test -n "$MV"; then
8379   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8380 $as_echo "$MV" >&6; }
8381 else
8382   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8383 $as_echo "no" >&6; }
8384 fi
8385 
8386 
8387   test -n "$MV" && break
8388 done
8389 
8390   else
8391     # The variable is set, but is it from the command line or the environment?
8392 
8393     # Try to remove the string !MV! from our list.
8394     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
8395     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8396       # If it failed, the variable was not from the command line. Ignore it,
8397       # but warn the user (except for BASH, which is always set by the calling BASH).
8398       if test "xMV" != xBASH; then
8399         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
8400 $as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
8401       fi
8402       # Try to locate tool using the code snippet
8403       for ac_prog in mv
8404 do
8405   # Extract the first word of "$ac_prog", so it can be a program name with args.
8406 set dummy $ac_prog; ac_word=$2
8407 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8408 $as_echo_n "checking for $ac_word... " >&6; }
8409 if ${ac_cv_path_MV+:} false; then :
8410   $as_echo_n "(cached) " >&6
8411 else
8412   case $MV in
8413   [\\/]* | ?:[\\/]*)
8414   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8415   ;;
8416   *)
8417   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8418 for as_dir in $PATH
8419 do
8420   IFS=$as_save_IFS
8421   test -z "$as_dir" && as_dir=.
8422     for ac_exec_ext in '' $ac_executable_extensions; do
8423   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8424     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8425     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8426     break 2
8427   fi
8428 done
8429   done
8430 IFS=$as_save_IFS
8431 
8432   ;;
8433 esac
8434 fi
8435 MV=$ac_cv_path_MV
8436 if test -n "$MV"; then
8437   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8438 $as_echo "$MV" >&6; }
8439 else
8440   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8441 $as_echo "no" >&6; }
8442 fi
8443 
8444 
8445   test -n "$MV" && break
8446 done
8447 
8448     else
8449       # If it succeeded, then it was overridden by the user. We will use it
8450       # for the tool.
8451 
8452       # First remove it from the list of overridden variables, so we can test
8453       # for unknown variables in the end.
8454       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8455 
8456       # Check if the provided tool contains a complete path.
8457       tool_specified="$MV"
8458       tool_basename="${tool_specified##*/}"
8459       if test "x$tool_basename" = "x$tool_specified"; then
8460         # A command without a complete path is provided, search $PATH.
8461         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
8462 $as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
8463         # Extract the first word of "$tool_basename", so it can be a program name with args.
8464 set dummy $tool_basename; ac_word=$2
8465 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8466 $as_echo_n "checking for $ac_word... " >&6; }
8467 if ${ac_cv_path_MV+:} false; then :
8468   $as_echo_n "(cached) " >&6
8469 else
8470   case $MV in
8471   [\\/]* | ?:[\\/]*)
8472   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8473   ;;
8474   *)
8475   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8476 for as_dir in $PATH
8477 do
8478   IFS=$as_save_IFS
8479   test -z "$as_dir" && as_dir=.
8480     for ac_exec_ext in '' $ac_executable_extensions; do
8481   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8482     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8483     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8484     break 2
8485   fi
8486 done
8487   done
8488 IFS=$as_save_IFS
8489 
8490   ;;
8491 esac
8492 fi
8493 MV=$ac_cv_path_MV
8494 if test -n "$MV"; then
8495   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8496 $as_echo "$MV" >&6; }
8497 else
8498   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8499 $as_echo "no" >&6; }
8500 fi
8501 
8502 
8503         if test "x$MV" = x; then
8504           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8505         fi
8506       else
8507         # Otherwise we believe it is a complete path. Use it as it is.
8508         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
8509 $as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
8510         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
8511 $as_echo_n "checking for MV... " >&6; }
8512         if test ! -x "$tool_specified"; then
8513           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8514 $as_echo "not found" >&6; }
8515           as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
8516         fi
8517         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8518 $as_echo "$tool_specified" >&6; }
8519       fi
8520     fi
8521   fi
8522 
8523 
8524 
8525   if test "x$MV" = x; then
8526     as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
8527   fi
8528 
8529 
8530 
8531 
8532 
8533   # Publish this variable in the help.
8534 
8535 
8536   if test "x$NAWK" = x; then
8537     # The variable is not set by user, try to locate tool using the code snippet
8538     for ac_prog in nawk gawk awk
8539 do
8540   # Extract the first word of "$ac_prog", so it can be a program name with args.
8541 set dummy $ac_prog; ac_word=$2
8542 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8543 $as_echo_n "checking for $ac_word... " >&6; }
8544 if ${ac_cv_path_NAWK+:} false; then :
8545   $as_echo_n "(cached) " >&6
8546 else
8547   case $NAWK in
8548   [\\/]* | ?:[\\/]*)
8549   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8550   ;;
8551   *)
8552   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8553 for as_dir in $PATH
8554 do
8555   IFS=$as_save_IFS
8556   test -z "$as_dir" && as_dir=.
8557     for ac_exec_ext in '' $ac_executable_extensions; do
8558   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8559     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8560     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8561     break 2
8562   fi
8563 done
8564   done
8565 IFS=$as_save_IFS
8566 
8567   ;;
8568 esac
8569 fi
8570 NAWK=$ac_cv_path_NAWK
8571 if test -n "$NAWK"; then
8572   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8573 $as_echo "$NAWK" >&6; }
8574 else
8575   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8576 $as_echo "no" >&6; }
8577 fi
8578 
8579 
8580   test -n "$NAWK" && break
8581 done
8582 
8583   else
8584     # The variable is set, but is it from the command line or the environment?
8585 
8586     # Try to remove the string !NAWK! from our list.
8587     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
8588     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8589       # If it failed, the variable was not from the command line. Ignore it,
8590       # but warn the user (except for BASH, which is always set by the calling BASH).
8591       if test "xNAWK" != xBASH; then
8592         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
8593 $as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
8594       fi
8595       # Try to locate tool using the code snippet
8596       for ac_prog in nawk gawk awk
8597 do
8598   # Extract the first word of "$ac_prog", so it can be a program name with args.
8599 set dummy $ac_prog; ac_word=$2
8600 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8601 $as_echo_n "checking for $ac_word... " >&6; }
8602 if ${ac_cv_path_NAWK+:} false; then :
8603   $as_echo_n "(cached) " >&6
8604 else
8605   case $NAWK in
8606   [\\/]* | ?:[\\/]*)
8607   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8608   ;;
8609   *)
8610   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8611 for as_dir in $PATH
8612 do
8613   IFS=$as_save_IFS
8614   test -z "$as_dir" && as_dir=.
8615     for ac_exec_ext in '' $ac_executable_extensions; do
8616   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8617     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8618     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8619     break 2
8620   fi
8621 done
8622   done
8623 IFS=$as_save_IFS
8624 
8625   ;;
8626 esac
8627 fi
8628 NAWK=$ac_cv_path_NAWK
8629 if test -n "$NAWK"; then
8630   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8631 $as_echo "$NAWK" >&6; }
8632 else
8633   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8634 $as_echo "no" >&6; }
8635 fi
8636 
8637 
8638   test -n "$NAWK" && break
8639 done
8640 
8641     else
8642       # If it succeeded, then it was overridden by the user. We will use it
8643       # for the tool.
8644 
8645       # First remove it from the list of overridden variables, so we can test
8646       # for unknown variables in the end.
8647       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8648 
8649       # Check if the provided tool contains a complete path.
8650       tool_specified="$NAWK"
8651       tool_basename="${tool_specified##*/}"
8652       if test "x$tool_basename" = "x$tool_specified"; then
8653         # A command without a complete path is provided, search $PATH.
8654         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
8655 $as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
8656         # Extract the first word of "$tool_basename", so it can be a program name with args.
8657 set dummy $tool_basename; ac_word=$2
8658 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8659 $as_echo_n "checking for $ac_word... " >&6; }
8660 if ${ac_cv_path_NAWK+:} false; then :
8661   $as_echo_n "(cached) " >&6
8662 else
8663   case $NAWK in
8664   [\\/]* | ?:[\\/]*)
8665   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8666   ;;
8667   *)
8668   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8669 for as_dir in $PATH
8670 do
8671   IFS=$as_save_IFS
8672   test -z "$as_dir" && as_dir=.
8673     for ac_exec_ext in '' $ac_executable_extensions; do
8674   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8675     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8676     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8677     break 2
8678   fi
8679 done
8680   done
8681 IFS=$as_save_IFS
8682 
8683   ;;
8684 esac
8685 fi
8686 NAWK=$ac_cv_path_NAWK
8687 if test -n "$NAWK"; then
8688   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8689 $as_echo "$NAWK" >&6; }
8690 else
8691   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8692 $as_echo "no" >&6; }
8693 fi
8694 
8695 
8696         if test "x$NAWK" = x; then
8697           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8698         fi
8699       else
8700         # Otherwise we believe it is a complete path. Use it as it is.
8701         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
8702 $as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
8703         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
8704 $as_echo_n "checking for NAWK... " >&6; }
8705         if test ! -x "$tool_specified"; then
8706           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8707 $as_echo "not found" >&6; }
8708           as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
8709         fi
8710         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8711 $as_echo "$tool_specified" >&6; }
8712       fi
8713     fi
8714   fi
8715 
8716 
8717 
8718   if test "x$NAWK" = x; then
8719     as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
8720   fi
8721 
8722 
8723 
8724 
8725 
8726   # Publish this variable in the help.
8727 
8728 
8729   if test "x$PRINTF" = x; then
8730     # The variable is not set by user, try to locate tool using the code snippet
8731     for ac_prog in printf
8732 do
8733   # Extract the first word of "$ac_prog", so it can be a program name with args.
8734 set dummy $ac_prog; ac_word=$2
8735 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8736 $as_echo_n "checking for $ac_word... " >&6; }
8737 if ${ac_cv_path_PRINTF+:} false; then :
8738   $as_echo_n "(cached) " >&6
8739 else
8740   case $PRINTF in
8741   [\\/]* | ?:[\\/]*)
8742   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8743   ;;
8744   *)
8745   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8746 for as_dir in $PATH
8747 do
8748   IFS=$as_save_IFS
8749   test -z "$as_dir" && as_dir=.
8750     for ac_exec_ext in '' $ac_executable_extensions; do
8751   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8752     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8753     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8754     break 2
8755   fi
8756 done
8757   done
8758 IFS=$as_save_IFS
8759 
8760   ;;
8761 esac
8762 fi
8763 PRINTF=$ac_cv_path_PRINTF
8764 if test -n "$PRINTF"; then
8765   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8766 $as_echo "$PRINTF" >&6; }
8767 else
8768   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8769 $as_echo "no" >&6; }
8770 fi
8771 
8772 
8773   test -n "$PRINTF" && break
8774 done
8775 
8776   else
8777     # The variable is set, but is it from the command line or the environment?
8778 
8779     # Try to remove the string !PRINTF! from our list.
8780     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
8781     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8782       # If it failed, the variable was not from the command line. Ignore it,
8783       # but warn the user (except for BASH, which is always set by the calling BASH).
8784       if test "xPRINTF" != xBASH; then
8785         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
8786 $as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
8787       fi
8788       # Try to locate tool using the code snippet
8789       for ac_prog in printf
8790 do
8791   # Extract the first word of "$ac_prog", so it can be a program name with args.
8792 set dummy $ac_prog; ac_word=$2
8793 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8794 $as_echo_n "checking for $ac_word... " >&6; }
8795 if ${ac_cv_path_PRINTF+:} false; then :
8796   $as_echo_n "(cached) " >&6
8797 else
8798   case $PRINTF in
8799   [\\/]* | ?:[\\/]*)
8800   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8801   ;;
8802   *)
8803   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8804 for as_dir in $PATH
8805 do
8806   IFS=$as_save_IFS
8807   test -z "$as_dir" && as_dir=.
8808     for ac_exec_ext in '' $ac_executable_extensions; do
8809   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8810     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8811     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8812     break 2
8813   fi
8814 done
8815   done
8816 IFS=$as_save_IFS
8817 
8818   ;;
8819 esac
8820 fi
8821 PRINTF=$ac_cv_path_PRINTF
8822 if test -n "$PRINTF"; then
8823   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8824 $as_echo "$PRINTF" >&6; }
8825 else
8826   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8827 $as_echo "no" >&6; }
8828 fi
8829 
8830 
8831   test -n "$PRINTF" && break
8832 done
8833 
8834     else
8835       # If it succeeded, then it was overridden by the user. We will use it
8836       # for the tool.
8837 
8838       # First remove it from the list of overridden variables, so we can test
8839       # for unknown variables in the end.
8840       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8841 
8842       # Check if the provided tool contains a complete path.
8843       tool_specified="$PRINTF"
8844       tool_basename="${tool_specified##*/}"
8845       if test "x$tool_basename" = "x$tool_specified"; then
8846         # A command without a complete path is provided, search $PATH.
8847         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
8848 $as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
8849         # Extract the first word of "$tool_basename", so it can be a program name with args.
8850 set dummy $tool_basename; ac_word=$2
8851 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8852 $as_echo_n "checking for $ac_word... " >&6; }
8853 if ${ac_cv_path_PRINTF+:} false; then :
8854   $as_echo_n "(cached) " >&6
8855 else
8856   case $PRINTF in
8857   [\\/]* | ?:[\\/]*)
8858   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8859   ;;
8860   *)
8861   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8862 for as_dir in $PATH
8863 do
8864   IFS=$as_save_IFS
8865   test -z "$as_dir" && as_dir=.
8866     for ac_exec_ext in '' $ac_executable_extensions; do
8867   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8868     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8869     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8870     break 2
8871   fi
8872 done
8873   done
8874 IFS=$as_save_IFS
8875 
8876   ;;
8877 esac
8878 fi
8879 PRINTF=$ac_cv_path_PRINTF
8880 if test -n "$PRINTF"; then
8881   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8882 $as_echo "$PRINTF" >&6; }
8883 else
8884   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8885 $as_echo "no" >&6; }
8886 fi
8887 
8888 
8889         if test "x$PRINTF" = x; then
8890           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8891         fi
8892       else
8893         # Otherwise we believe it is a complete path. Use it as it is.
8894         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
8895 $as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
8896         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
8897 $as_echo_n "checking for PRINTF... " >&6; }
8898         if test ! -x "$tool_specified"; then
8899           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8900 $as_echo "not found" >&6; }
8901           as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
8902         fi
8903         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8904 $as_echo "$tool_specified" >&6; }
8905       fi
8906     fi
8907   fi
8908 
8909 
8910 
8911   if test "x$PRINTF" = x; then
8912     as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
8913   fi
8914 
8915 
8916 
8917 
8918 
8919   # Publish this variable in the help.
8920 
8921 
8922   if test "x$RM" = x; then
8923     # The variable is not set by user, try to locate tool using the code snippet
8924     for ac_prog in rm
8925 do
8926   # Extract the first word of "$ac_prog", so it can be a program name with args.
8927 set dummy $ac_prog; ac_word=$2
8928 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8929 $as_echo_n "checking for $ac_word... " >&6; }
8930 if ${ac_cv_path_RM+:} false; then :
8931   $as_echo_n "(cached) " >&6
8932 else
8933   case $RM in
8934   [\\/]* | ?:[\\/]*)
8935   ac_cv_path_RM="$RM" # Let the user override the test with a path.
8936   ;;
8937   *)
8938   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8939 for as_dir in $PATH
8940 do
8941   IFS=$as_save_IFS
8942   test -z "$as_dir" && as_dir=.
8943     for ac_exec_ext in '' $ac_executable_extensions; do
8944   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8945     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8946     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8947     break 2
8948   fi
8949 done
8950   done
8951 IFS=$as_save_IFS
8952 
8953   ;;
8954 esac
8955 fi
8956 RM=$ac_cv_path_RM
8957 if test -n "$RM"; then
8958   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8959 $as_echo "$RM" >&6; }
8960 else
8961   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8962 $as_echo "no" >&6; }
8963 fi
8964 
8965 
8966   test -n "$RM" && break
8967 done
8968 
8969   else
8970     # The variable is set, but is it from the command line or the environment?
8971 
8972     # Try to remove the string !RM! from our list.
8973     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
8974     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8975       # If it failed, the variable was not from the command line. Ignore it,
8976       # but warn the user (except for BASH, which is always set by the calling BASH).
8977       if test "xRM" != xBASH; then
8978         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
8979 $as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
8980       fi
8981       # Try to locate tool using the code snippet
8982       for ac_prog in rm
8983 do
8984   # Extract the first word of "$ac_prog", so it can be a program name with args.
8985 set dummy $ac_prog; ac_word=$2
8986 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8987 $as_echo_n "checking for $ac_word... " >&6; }
8988 if ${ac_cv_path_RM+:} false; then :
8989   $as_echo_n "(cached) " >&6
8990 else
8991   case $RM in
8992   [\\/]* | ?:[\\/]*)
8993   ac_cv_path_RM="$RM" # Let the user override the test with a path.
8994   ;;
8995   *)
8996   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8997 for as_dir in $PATH
8998 do
8999   IFS=$as_save_IFS
9000   test -z "$as_dir" && as_dir=.
9001     for ac_exec_ext in '' $ac_executable_extensions; do
9002   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9003     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9004     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9005     break 2
9006   fi
9007 done
9008   done
9009 IFS=$as_save_IFS
9010 
9011   ;;
9012 esac
9013 fi
9014 RM=$ac_cv_path_RM
9015 if test -n "$RM"; then
9016   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9017 $as_echo "$RM" >&6; }
9018 else
9019   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9020 $as_echo "no" >&6; }
9021 fi
9022 
9023 
9024   test -n "$RM" && break
9025 done
9026 
9027     else
9028       # If it succeeded, then it was overridden by the user. We will use it
9029       # for the tool.
9030 
9031       # First remove it from the list of overridden variables, so we can test
9032       # for unknown variables in the end.
9033       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9034 
9035       # Check if the provided tool contains a complete path.
9036       tool_specified="$RM"
9037       tool_basename="${tool_specified##*/}"
9038       if test "x$tool_basename" = "x$tool_specified"; then
9039         # A command without a complete path is provided, search $PATH.
9040         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
9041 $as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
9042         # Extract the first word of "$tool_basename", so it can be a program name with args.
9043 set dummy $tool_basename; ac_word=$2
9044 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9045 $as_echo_n "checking for $ac_word... " >&6; }
9046 if ${ac_cv_path_RM+:} false; then :
9047   $as_echo_n "(cached) " >&6
9048 else
9049   case $RM in
9050   [\\/]* | ?:[\\/]*)
9051   ac_cv_path_RM="$RM" # Let the user override the test with a path.
9052   ;;
9053   *)
9054   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9055 for as_dir in $PATH
9056 do
9057   IFS=$as_save_IFS
9058   test -z "$as_dir" && as_dir=.
9059     for ac_exec_ext in '' $ac_executable_extensions; do
9060   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9061     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9062     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9063     break 2
9064   fi
9065 done
9066   done
9067 IFS=$as_save_IFS
9068 
9069   ;;
9070 esac
9071 fi
9072 RM=$ac_cv_path_RM
9073 if test -n "$RM"; then
9074   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9075 $as_echo "$RM" >&6; }
9076 else
9077   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9078 $as_echo "no" >&6; }
9079 fi
9080 
9081 
9082         if test "x$RM" = x; then
9083           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9084         fi
9085       else
9086         # Otherwise we believe it is a complete path. Use it as it is.
9087         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
9088 $as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
9089         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
9090 $as_echo_n "checking for RM... " >&6; }
9091         if test ! -x "$tool_specified"; then
9092           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9093 $as_echo "not found" >&6; }
9094           as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
9095         fi
9096         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9097 $as_echo "$tool_specified" >&6; }
9098       fi
9099     fi
9100   fi
9101 
9102 
9103 
9104   if test "x$RM" = x; then
9105     as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
9106   fi
9107 
9108 
9109 
9110 
9111 
9112   # Publish this variable in the help.
9113 
9114 
9115   if test "x$SH" = x; then
9116     # The variable is not set by user, try to locate tool using the code snippet
9117     for ac_prog in sh
9118 do
9119   # Extract the first word of "$ac_prog", so it can be a program name with args.
9120 set dummy $ac_prog; ac_word=$2
9121 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9122 $as_echo_n "checking for $ac_word... " >&6; }
9123 if ${ac_cv_path_SH+:} false; then :
9124   $as_echo_n "(cached) " >&6
9125 else
9126   case $SH in
9127   [\\/]* | ?:[\\/]*)
9128   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9129   ;;
9130   *)
9131   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9132 for as_dir in $PATH
9133 do
9134   IFS=$as_save_IFS
9135   test -z "$as_dir" && as_dir=.
9136     for ac_exec_ext in '' $ac_executable_extensions; do
9137   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9138     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9139     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9140     break 2
9141   fi
9142 done
9143   done
9144 IFS=$as_save_IFS
9145 
9146   ;;
9147 esac
9148 fi
9149 SH=$ac_cv_path_SH
9150 if test -n "$SH"; then
9151   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9152 $as_echo "$SH" >&6; }
9153 else
9154   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9155 $as_echo "no" >&6; }
9156 fi
9157 
9158 
9159   test -n "$SH" && break
9160 done
9161 
9162   else
9163     # The variable is set, but is it from the command line or the environment?
9164 
9165     # Try to remove the string !SH! from our list.
9166     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
9167     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9168       # If it failed, the variable was not from the command line. Ignore it,
9169       # but warn the user (except for BASH, which is always set by the calling BASH).
9170       if test "xSH" != xBASH; then
9171         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
9172 $as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
9173       fi
9174       # Try to locate tool using the code snippet
9175       for ac_prog in sh
9176 do
9177   # Extract the first word of "$ac_prog", so it can be a program name with args.
9178 set dummy $ac_prog; ac_word=$2
9179 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9180 $as_echo_n "checking for $ac_word... " >&6; }
9181 if ${ac_cv_path_SH+:} false; then :
9182   $as_echo_n "(cached) " >&6
9183 else
9184   case $SH in
9185   [\\/]* | ?:[\\/]*)
9186   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9187   ;;
9188   *)
9189   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9190 for as_dir in $PATH
9191 do
9192   IFS=$as_save_IFS
9193   test -z "$as_dir" && as_dir=.
9194     for ac_exec_ext in '' $ac_executable_extensions; do
9195   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9196     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9197     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9198     break 2
9199   fi
9200 done
9201   done
9202 IFS=$as_save_IFS
9203 
9204   ;;
9205 esac
9206 fi
9207 SH=$ac_cv_path_SH
9208 if test -n "$SH"; then
9209   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9210 $as_echo "$SH" >&6; }
9211 else
9212   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9213 $as_echo "no" >&6; }
9214 fi
9215 
9216 
9217   test -n "$SH" && break
9218 done
9219 
9220     else
9221       # If it succeeded, then it was overridden by the user. We will use it
9222       # for the tool.
9223 
9224       # First remove it from the list of overridden variables, so we can test
9225       # for unknown variables in the end.
9226       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9227 
9228       # Check if the provided tool contains a complete path.
9229       tool_specified="$SH"
9230       tool_basename="${tool_specified##*/}"
9231       if test "x$tool_basename" = "x$tool_specified"; then
9232         # A command without a complete path is provided, search $PATH.
9233         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
9234 $as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
9235         # Extract the first word of "$tool_basename", so it can be a program name with args.
9236 set dummy $tool_basename; ac_word=$2
9237 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9238 $as_echo_n "checking for $ac_word... " >&6; }
9239 if ${ac_cv_path_SH+:} false; then :
9240   $as_echo_n "(cached) " >&6
9241 else
9242   case $SH in
9243   [\\/]* | ?:[\\/]*)
9244   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9245   ;;
9246   *)
9247   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9248 for as_dir in $PATH
9249 do
9250   IFS=$as_save_IFS
9251   test -z "$as_dir" && as_dir=.
9252     for ac_exec_ext in '' $ac_executable_extensions; do
9253   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9254     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9255     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9256     break 2
9257   fi
9258 done
9259   done
9260 IFS=$as_save_IFS
9261 
9262   ;;
9263 esac
9264 fi
9265 SH=$ac_cv_path_SH
9266 if test -n "$SH"; then
9267   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9268 $as_echo "$SH" >&6; }
9269 else
9270   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9271 $as_echo "no" >&6; }
9272 fi
9273 
9274 
9275         if test "x$SH" = x; then
9276           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9277         fi
9278       else
9279         # Otherwise we believe it is a complete path. Use it as it is.
9280         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
9281 $as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
9282         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
9283 $as_echo_n "checking for SH... " >&6; }
9284         if test ! -x "$tool_specified"; then
9285           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9286 $as_echo "not found" >&6; }
9287           as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
9288         fi
9289         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9290 $as_echo "$tool_specified" >&6; }
9291       fi
9292     fi
9293   fi
9294 
9295 
9296 
9297   if test "x$SH" = x; then
9298     as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
9299   fi
9300 
9301 
9302 
9303 
9304 
9305   # Publish this variable in the help.
9306 
9307 
9308   if test "x$SORT" = x; then
9309     # The variable is not set by user, try to locate tool using the code snippet
9310     for ac_prog in sort
9311 do
9312   # Extract the first word of "$ac_prog", so it can be a program name with args.
9313 set dummy $ac_prog; ac_word=$2
9314 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9315 $as_echo_n "checking for $ac_word... " >&6; }
9316 if ${ac_cv_path_SORT+:} false; then :
9317   $as_echo_n "(cached) " >&6
9318 else
9319   case $SORT in
9320   [\\/]* | ?:[\\/]*)
9321   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9322   ;;
9323   *)
9324   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9325 for as_dir in $PATH
9326 do
9327   IFS=$as_save_IFS
9328   test -z "$as_dir" && as_dir=.
9329     for ac_exec_ext in '' $ac_executable_extensions; do
9330   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9331     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9332     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9333     break 2
9334   fi
9335 done
9336   done
9337 IFS=$as_save_IFS
9338 
9339   ;;
9340 esac
9341 fi
9342 SORT=$ac_cv_path_SORT
9343 if test -n "$SORT"; then
9344   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9345 $as_echo "$SORT" >&6; }
9346 else
9347   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9348 $as_echo "no" >&6; }
9349 fi
9350 
9351 
9352   test -n "$SORT" && break
9353 done
9354 
9355   else
9356     # The variable is set, but is it from the command line or the environment?
9357 
9358     # Try to remove the string !SORT! from our list.
9359     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
9360     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9361       # If it failed, the variable was not from the command line. Ignore it,
9362       # but warn the user (except for BASH, which is always set by the calling BASH).
9363       if test "xSORT" != xBASH; then
9364         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
9365 $as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
9366       fi
9367       # Try to locate tool using the code snippet
9368       for ac_prog in sort
9369 do
9370   # Extract the first word of "$ac_prog", so it can be a program name with args.
9371 set dummy $ac_prog; ac_word=$2
9372 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9373 $as_echo_n "checking for $ac_word... " >&6; }
9374 if ${ac_cv_path_SORT+:} false; then :
9375   $as_echo_n "(cached) " >&6
9376 else
9377   case $SORT in
9378   [\\/]* | ?:[\\/]*)
9379   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9380   ;;
9381   *)
9382   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9383 for as_dir in $PATH
9384 do
9385   IFS=$as_save_IFS
9386   test -z "$as_dir" && as_dir=.
9387     for ac_exec_ext in '' $ac_executable_extensions; do
9388   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9389     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9390     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9391     break 2
9392   fi
9393 done
9394   done
9395 IFS=$as_save_IFS
9396 
9397   ;;
9398 esac
9399 fi
9400 SORT=$ac_cv_path_SORT
9401 if test -n "$SORT"; then
9402   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9403 $as_echo "$SORT" >&6; }
9404 else
9405   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9406 $as_echo "no" >&6; }
9407 fi
9408 
9409 
9410   test -n "$SORT" && break
9411 done
9412 
9413     else
9414       # If it succeeded, then it was overridden by the user. We will use it
9415       # for the tool.
9416 
9417       # First remove it from the list of overridden variables, so we can test
9418       # for unknown variables in the end.
9419       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9420 
9421       # Check if the provided tool contains a complete path.
9422       tool_specified="$SORT"
9423       tool_basename="${tool_specified##*/}"
9424       if test "x$tool_basename" = "x$tool_specified"; then
9425         # A command without a complete path is provided, search $PATH.
9426         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
9427 $as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
9428         # Extract the first word of "$tool_basename", so it can be a program name with args.
9429 set dummy $tool_basename; ac_word=$2
9430 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9431 $as_echo_n "checking for $ac_word... " >&6; }
9432 if ${ac_cv_path_SORT+:} false; then :
9433   $as_echo_n "(cached) " >&6
9434 else
9435   case $SORT in
9436   [\\/]* | ?:[\\/]*)
9437   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9438   ;;
9439   *)
9440   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9441 for as_dir in $PATH
9442 do
9443   IFS=$as_save_IFS
9444   test -z "$as_dir" && as_dir=.
9445     for ac_exec_ext in '' $ac_executable_extensions; do
9446   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9447     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9448     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9449     break 2
9450   fi
9451 done
9452   done
9453 IFS=$as_save_IFS
9454 
9455   ;;
9456 esac
9457 fi
9458 SORT=$ac_cv_path_SORT
9459 if test -n "$SORT"; then
9460   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9461 $as_echo "$SORT" >&6; }
9462 else
9463   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9464 $as_echo "no" >&6; }
9465 fi
9466 
9467 
9468         if test "x$SORT" = x; then
9469           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9470         fi
9471       else
9472         # Otherwise we believe it is a complete path. Use it as it is.
9473         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
9474 $as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
9475         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
9476 $as_echo_n "checking for SORT... " >&6; }
9477         if test ! -x "$tool_specified"; then
9478           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9479 $as_echo "not found" >&6; }
9480           as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
9481         fi
9482         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9483 $as_echo "$tool_specified" >&6; }
9484       fi
9485     fi
9486   fi
9487 
9488 
9489 
9490   if test "x$SORT" = x; then
9491     as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
9492   fi
9493 
9494 
9495 
9496 
9497 
9498   # Publish this variable in the help.
9499 
9500 
9501   if test "x$TAIL" = x; then
9502     # The variable is not set by user, try to locate tool using the code snippet
9503     for ac_prog in tail
9504 do
9505   # Extract the first word of "$ac_prog", so it can be a program name with args.
9506 set dummy $ac_prog; ac_word=$2
9507 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9508 $as_echo_n "checking for $ac_word... " >&6; }
9509 if ${ac_cv_path_TAIL+:} false; then :
9510   $as_echo_n "(cached) " >&6
9511 else
9512   case $TAIL in
9513   [\\/]* | ?:[\\/]*)
9514   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9515   ;;
9516   *)
9517   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9518 for as_dir in $PATH
9519 do
9520   IFS=$as_save_IFS
9521   test -z "$as_dir" && as_dir=.
9522     for ac_exec_ext in '' $ac_executable_extensions; do
9523   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9524     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9525     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9526     break 2
9527   fi
9528 done
9529   done
9530 IFS=$as_save_IFS
9531 
9532   ;;
9533 esac
9534 fi
9535 TAIL=$ac_cv_path_TAIL
9536 if test -n "$TAIL"; then
9537   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9538 $as_echo "$TAIL" >&6; }
9539 else
9540   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9541 $as_echo "no" >&6; }
9542 fi
9543 
9544 
9545   test -n "$TAIL" && break
9546 done
9547 
9548   else
9549     # The variable is set, but is it from the command line or the environment?
9550 
9551     # Try to remove the string !TAIL! from our list.
9552     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
9553     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9554       # If it failed, the variable was not from the command line. Ignore it,
9555       # but warn the user (except for BASH, which is always set by the calling BASH).
9556       if test "xTAIL" != xBASH; then
9557         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
9558 $as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
9559       fi
9560       # Try to locate tool using the code snippet
9561       for ac_prog in tail
9562 do
9563   # Extract the first word of "$ac_prog", so it can be a program name with args.
9564 set dummy $ac_prog; ac_word=$2
9565 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9566 $as_echo_n "checking for $ac_word... " >&6; }
9567 if ${ac_cv_path_TAIL+:} false; then :
9568   $as_echo_n "(cached) " >&6
9569 else
9570   case $TAIL in
9571   [\\/]* | ?:[\\/]*)
9572   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9573   ;;
9574   *)
9575   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9576 for as_dir in $PATH
9577 do
9578   IFS=$as_save_IFS
9579   test -z "$as_dir" && as_dir=.
9580     for ac_exec_ext in '' $ac_executable_extensions; do
9581   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9582     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9583     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9584     break 2
9585   fi
9586 done
9587   done
9588 IFS=$as_save_IFS
9589 
9590   ;;
9591 esac
9592 fi
9593 TAIL=$ac_cv_path_TAIL
9594 if test -n "$TAIL"; then
9595   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9596 $as_echo "$TAIL" >&6; }
9597 else
9598   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9599 $as_echo "no" >&6; }
9600 fi
9601 
9602 
9603   test -n "$TAIL" && break
9604 done
9605 
9606     else
9607       # If it succeeded, then it was overridden by the user. We will use it
9608       # for the tool.
9609 
9610       # First remove it from the list of overridden variables, so we can test
9611       # for unknown variables in the end.
9612       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9613 
9614       # Check if the provided tool contains a complete path.
9615       tool_specified="$TAIL"
9616       tool_basename="${tool_specified##*/}"
9617       if test "x$tool_basename" = "x$tool_specified"; then
9618         # A command without a complete path is provided, search $PATH.
9619         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
9620 $as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
9621         # Extract the first word of "$tool_basename", so it can be a program name with args.
9622 set dummy $tool_basename; ac_word=$2
9623 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9624 $as_echo_n "checking for $ac_word... " >&6; }
9625 if ${ac_cv_path_TAIL+:} false; then :
9626   $as_echo_n "(cached) " >&6
9627 else
9628   case $TAIL in
9629   [\\/]* | ?:[\\/]*)
9630   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9631   ;;
9632   *)
9633   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9634 for as_dir in $PATH
9635 do
9636   IFS=$as_save_IFS
9637   test -z "$as_dir" && as_dir=.
9638     for ac_exec_ext in '' $ac_executable_extensions; do
9639   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9640     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9641     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9642     break 2
9643   fi
9644 done
9645   done
9646 IFS=$as_save_IFS
9647 
9648   ;;
9649 esac
9650 fi
9651 TAIL=$ac_cv_path_TAIL
9652 if test -n "$TAIL"; then
9653   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9654 $as_echo "$TAIL" >&6; }
9655 else
9656   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9657 $as_echo "no" >&6; }
9658 fi
9659 
9660 
9661         if test "x$TAIL" = x; then
9662           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9663         fi
9664       else
9665         # Otherwise we believe it is a complete path. Use it as it is.
9666         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
9667 $as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
9668         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
9669 $as_echo_n "checking for TAIL... " >&6; }
9670         if test ! -x "$tool_specified"; then
9671           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9672 $as_echo "not found" >&6; }
9673           as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
9674         fi
9675         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9676 $as_echo "$tool_specified" >&6; }
9677       fi
9678     fi
9679   fi
9680 
9681 
9682 
9683   if test "x$TAIL" = x; then
9684     as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
9685   fi
9686 
9687 
9688 
9689 
9690 
9691   # Publish this variable in the help.
9692 
9693 
9694   if test "x$TAR" = x; then
9695     # The variable is not set by user, try to locate tool using the code snippet
9696     for ac_prog in tar
9697 do
9698   # Extract the first word of "$ac_prog", so it can be a program name with args.
9699 set dummy $ac_prog; ac_word=$2
9700 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9701 $as_echo_n "checking for $ac_word... " >&6; }
9702 if ${ac_cv_path_TAR+:} false; then :
9703   $as_echo_n "(cached) " >&6
9704 else
9705   case $TAR in
9706   [\\/]* | ?:[\\/]*)
9707   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9708   ;;
9709   *)
9710   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9711 for as_dir in $PATH
9712 do
9713   IFS=$as_save_IFS
9714   test -z "$as_dir" && as_dir=.
9715     for ac_exec_ext in '' $ac_executable_extensions; do
9716   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9717     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9718     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9719     break 2
9720   fi
9721 done
9722   done
9723 IFS=$as_save_IFS
9724 
9725   ;;
9726 esac
9727 fi
9728 TAR=$ac_cv_path_TAR
9729 if test -n "$TAR"; then
9730   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9731 $as_echo "$TAR" >&6; }
9732 else
9733   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9734 $as_echo "no" >&6; }
9735 fi
9736 
9737 
9738   test -n "$TAR" && break
9739 done
9740 
9741   else
9742     # The variable is set, but is it from the command line or the environment?
9743 
9744     # Try to remove the string !TAR! from our list.
9745     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
9746     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9747       # If it failed, the variable was not from the command line. Ignore it,
9748       # but warn the user (except for BASH, which is always set by the calling BASH).
9749       if test "xTAR" != xBASH; then
9750         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
9751 $as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
9752       fi
9753       # Try to locate tool using the code snippet
9754       for ac_prog in tar
9755 do
9756   # Extract the first word of "$ac_prog", so it can be a program name with args.
9757 set dummy $ac_prog; ac_word=$2
9758 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9759 $as_echo_n "checking for $ac_word... " >&6; }
9760 if ${ac_cv_path_TAR+:} false; then :
9761   $as_echo_n "(cached) " >&6
9762 else
9763   case $TAR in
9764   [\\/]* | ?:[\\/]*)
9765   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9766   ;;
9767   *)
9768   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9769 for as_dir in $PATH
9770 do
9771   IFS=$as_save_IFS
9772   test -z "$as_dir" && as_dir=.
9773     for ac_exec_ext in '' $ac_executable_extensions; do
9774   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9775     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9776     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9777     break 2
9778   fi
9779 done
9780   done
9781 IFS=$as_save_IFS
9782 
9783   ;;
9784 esac
9785 fi
9786 TAR=$ac_cv_path_TAR
9787 if test -n "$TAR"; then
9788   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9789 $as_echo "$TAR" >&6; }
9790 else
9791   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9792 $as_echo "no" >&6; }
9793 fi
9794 
9795 
9796   test -n "$TAR" && break
9797 done
9798 
9799     else
9800       # If it succeeded, then it was overridden by the user. We will use it
9801       # for the tool.
9802 
9803       # First remove it from the list of overridden variables, so we can test
9804       # for unknown variables in the end.
9805       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9806 
9807       # Check if the provided tool contains a complete path.
9808       tool_specified="$TAR"
9809       tool_basename="${tool_specified##*/}"
9810       if test "x$tool_basename" = "x$tool_specified"; then
9811         # A command without a complete path is provided, search $PATH.
9812         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
9813 $as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
9814         # Extract the first word of "$tool_basename", so it can be a program name with args.
9815 set dummy $tool_basename; ac_word=$2
9816 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9817 $as_echo_n "checking for $ac_word... " >&6; }
9818 if ${ac_cv_path_TAR+:} false; then :
9819   $as_echo_n "(cached) " >&6
9820 else
9821   case $TAR in
9822   [\\/]* | ?:[\\/]*)
9823   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9824   ;;
9825   *)
9826   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9827 for as_dir in $PATH
9828 do
9829   IFS=$as_save_IFS
9830   test -z "$as_dir" && as_dir=.
9831     for ac_exec_ext in '' $ac_executable_extensions; do
9832   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9833     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9834     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9835     break 2
9836   fi
9837 done
9838   done
9839 IFS=$as_save_IFS
9840 
9841   ;;
9842 esac
9843 fi
9844 TAR=$ac_cv_path_TAR
9845 if test -n "$TAR"; then
9846   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9847 $as_echo "$TAR" >&6; }
9848 else
9849   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9850 $as_echo "no" >&6; }
9851 fi
9852 
9853 
9854         if test "x$TAR" = x; then
9855           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9856         fi
9857       else
9858         # Otherwise we believe it is a complete path. Use it as it is.
9859         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
9860 $as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
9861         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
9862 $as_echo_n "checking for TAR... " >&6; }
9863         if test ! -x "$tool_specified"; then
9864           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9865 $as_echo "not found" >&6; }
9866           as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
9867         fi
9868         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9869 $as_echo "$tool_specified" >&6; }
9870       fi
9871     fi
9872   fi
9873 
9874 
9875 
9876   if test "x$TAR" = x; then
9877     as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
9878   fi
9879 
9880 
9881 
9882 
9883 
9884   # Publish this variable in the help.
9885 
9886 
9887   if test "x$TEE" = x; then
9888     # The variable is not set by user, try to locate tool using the code snippet
9889     for ac_prog in tee
9890 do
9891   # Extract the first word of "$ac_prog", so it can be a program name with args.
9892 set dummy $ac_prog; ac_word=$2
9893 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9894 $as_echo_n "checking for $ac_word... " >&6; }
9895 if ${ac_cv_path_TEE+:} false; then :
9896   $as_echo_n "(cached) " >&6
9897 else
9898   case $TEE in
9899   [\\/]* | ?:[\\/]*)
9900   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9901   ;;
9902   *)
9903   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9904 for as_dir in $PATH
9905 do
9906   IFS=$as_save_IFS
9907   test -z "$as_dir" && as_dir=.
9908     for ac_exec_ext in '' $ac_executable_extensions; do
9909   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9910     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9911     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9912     break 2
9913   fi
9914 done
9915   done
9916 IFS=$as_save_IFS
9917 
9918   ;;
9919 esac
9920 fi
9921 TEE=$ac_cv_path_TEE
9922 if test -n "$TEE"; then
9923   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9924 $as_echo "$TEE" >&6; }
9925 else
9926   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9927 $as_echo "no" >&6; }
9928 fi
9929 
9930 
9931   test -n "$TEE" && break
9932 done
9933 
9934   else
9935     # The variable is set, but is it from the command line or the environment?
9936 
9937     # Try to remove the string !TEE! from our list.
9938     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
9939     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9940       # If it failed, the variable was not from the command line. Ignore it,
9941       # but warn the user (except for BASH, which is always set by the calling BASH).
9942       if test "xTEE" != xBASH; then
9943         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
9944 $as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
9945       fi
9946       # Try to locate tool using the code snippet
9947       for ac_prog in tee
9948 do
9949   # Extract the first word of "$ac_prog", so it can be a program name with args.
9950 set dummy $ac_prog; ac_word=$2
9951 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9952 $as_echo_n "checking for $ac_word... " >&6; }
9953 if ${ac_cv_path_TEE+:} false; then :
9954   $as_echo_n "(cached) " >&6
9955 else
9956   case $TEE in
9957   [\\/]* | ?:[\\/]*)
9958   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9959   ;;
9960   *)
9961   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9962 for as_dir in $PATH
9963 do
9964   IFS=$as_save_IFS
9965   test -z "$as_dir" && as_dir=.
9966     for ac_exec_ext in '' $ac_executable_extensions; do
9967   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9968     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9969     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9970     break 2
9971   fi
9972 done
9973   done
9974 IFS=$as_save_IFS
9975 
9976   ;;
9977 esac
9978 fi
9979 TEE=$ac_cv_path_TEE
9980 if test -n "$TEE"; then
9981   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9982 $as_echo "$TEE" >&6; }
9983 else
9984   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9985 $as_echo "no" >&6; }
9986 fi
9987 
9988 
9989   test -n "$TEE" && break
9990 done
9991 
9992     else
9993       # If it succeeded, then it was overridden by the user. We will use it
9994       # for the tool.
9995 
9996       # First remove it from the list of overridden variables, so we can test
9997       # for unknown variables in the end.
9998       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9999 
10000       # Check if the provided tool contains a complete path.
10001       tool_specified="$TEE"
10002       tool_basename="${tool_specified##*/}"
10003       if test "x$tool_basename" = "x$tool_specified"; then
10004         # A command without a complete path is provided, search $PATH.
10005         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
10006 $as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
10007         # Extract the first word of "$tool_basename", so it can be a program name with args.
10008 set dummy $tool_basename; ac_word=$2
10009 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10010 $as_echo_n "checking for $ac_word... " >&6; }
10011 if ${ac_cv_path_TEE+:} false; then :
10012   $as_echo_n "(cached) " >&6
10013 else
10014   case $TEE in
10015   [\\/]* | ?:[\\/]*)
10016   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
10017   ;;
10018   *)
10019   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10020 for as_dir in $PATH
10021 do
10022   IFS=$as_save_IFS
10023   test -z "$as_dir" && as_dir=.
10024     for ac_exec_ext in '' $ac_executable_extensions; do
10025   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10026     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
10027     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10028     break 2
10029   fi
10030 done
10031   done
10032 IFS=$as_save_IFS
10033 
10034   ;;
10035 esac
10036 fi
10037 TEE=$ac_cv_path_TEE
10038 if test -n "$TEE"; then
10039   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
10040 $as_echo "$TEE" >&6; }
10041 else
10042   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10043 $as_echo "no" >&6; }
10044 fi
10045 
10046 
10047         if test "x$TEE" = x; then
10048           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10049         fi
10050       else
10051         # Otherwise we believe it is a complete path. Use it as it is.
10052         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
10053 $as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
10054         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
10055 $as_echo_n "checking for TEE... " >&6; }
10056         if test ! -x "$tool_specified"; then
10057           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10058 $as_echo "not found" >&6; }
10059           as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
10060         fi
10061         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10062 $as_echo "$tool_specified" >&6; }
10063       fi
10064     fi
10065   fi
10066 
10067 
10068 
10069   if test "x$TEE" = x; then
10070     as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
10071   fi
10072 
10073 
10074 
10075 
10076 
10077   # Publish this variable in the help.
10078 
10079 
10080   if test "x$TOUCH" = x; then
10081     # The variable is not set by user, try to locate tool using the code snippet
10082     for ac_prog in touch
10083 do
10084   # Extract the first word of "$ac_prog", so it can be a program name with args.
10085 set dummy $ac_prog; ac_word=$2
10086 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10087 $as_echo_n "checking for $ac_word... " >&6; }
10088 if ${ac_cv_path_TOUCH+:} false; then :
10089   $as_echo_n "(cached) " >&6
10090 else
10091   case $TOUCH in
10092   [\\/]* | ?:[\\/]*)
10093   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10094   ;;
10095   *)
10096   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10097 for as_dir in $PATH
10098 do
10099   IFS=$as_save_IFS
10100   test -z "$as_dir" && as_dir=.
10101     for ac_exec_ext in '' $ac_executable_extensions; do
10102   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10103     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10104     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10105     break 2
10106   fi
10107 done
10108   done
10109 IFS=$as_save_IFS
10110 
10111   ;;
10112 esac
10113 fi
10114 TOUCH=$ac_cv_path_TOUCH
10115 if test -n "$TOUCH"; then
10116   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10117 $as_echo "$TOUCH" >&6; }
10118 else
10119   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10120 $as_echo "no" >&6; }
10121 fi
10122 
10123 
10124   test -n "$TOUCH" && break
10125 done
10126 
10127   else
10128     # The variable is set, but is it from the command line or the environment?
10129 
10130     # Try to remove the string !TOUCH! from our list.
10131     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
10132     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10133       # If it failed, the variable was not from the command line. Ignore it,
10134       # but warn the user (except for BASH, which is always set by the calling BASH).
10135       if test "xTOUCH" != xBASH; then
10136         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
10137 $as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
10138       fi
10139       # Try to locate tool using the code snippet
10140       for ac_prog in touch
10141 do
10142   # Extract the first word of "$ac_prog", so it can be a program name with args.
10143 set dummy $ac_prog; ac_word=$2
10144 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10145 $as_echo_n "checking for $ac_word... " >&6; }
10146 if ${ac_cv_path_TOUCH+:} false; then :
10147   $as_echo_n "(cached) " >&6
10148 else
10149   case $TOUCH in
10150   [\\/]* | ?:[\\/]*)
10151   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10152   ;;
10153   *)
10154   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10155 for as_dir in $PATH
10156 do
10157   IFS=$as_save_IFS
10158   test -z "$as_dir" && as_dir=.
10159     for ac_exec_ext in '' $ac_executable_extensions; do
10160   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10161     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10162     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10163     break 2
10164   fi
10165 done
10166   done
10167 IFS=$as_save_IFS
10168 
10169   ;;
10170 esac
10171 fi
10172 TOUCH=$ac_cv_path_TOUCH
10173 if test -n "$TOUCH"; then
10174   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10175 $as_echo "$TOUCH" >&6; }
10176 else
10177   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10178 $as_echo "no" >&6; }
10179 fi
10180 
10181 
10182   test -n "$TOUCH" && break
10183 done
10184 
10185     else
10186       # If it succeeded, then it was overridden by the user. We will use it
10187       # for the tool.
10188 
10189       # First remove it from the list of overridden variables, so we can test
10190       # for unknown variables in the end.
10191       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10192 
10193       # Check if the provided tool contains a complete path.
10194       tool_specified="$TOUCH"
10195       tool_basename="${tool_specified##*/}"
10196       if test "x$tool_basename" = "x$tool_specified"; then
10197         # A command without a complete path is provided, search $PATH.
10198         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
10199 $as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
10200         # Extract the first word of "$tool_basename", so it can be a program name with args.
10201 set dummy $tool_basename; ac_word=$2
10202 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10203 $as_echo_n "checking for $ac_word... " >&6; }
10204 if ${ac_cv_path_TOUCH+:} false; then :
10205   $as_echo_n "(cached) " >&6
10206 else
10207   case $TOUCH in
10208   [\\/]* | ?:[\\/]*)
10209   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10210   ;;
10211   *)
10212   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10213 for as_dir in $PATH
10214 do
10215   IFS=$as_save_IFS
10216   test -z "$as_dir" && as_dir=.
10217     for ac_exec_ext in '' $ac_executable_extensions; do
10218   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10219     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10220     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10221     break 2
10222   fi
10223 done
10224   done
10225 IFS=$as_save_IFS
10226 
10227   ;;
10228 esac
10229 fi
10230 TOUCH=$ac_cv_path_TOUCH
10231 if test -n "$TOUCH"; then
10232   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10233 $as_echo "$TOUCH" >&6; }
10234 else
10235   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10236 $as_echo "no" >&6; }
10237 fi
10238 
10239 
10240         if test "x$TOUCH" = x; then
10241           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10242         fi
10243       else
10244         # Otherwise we believe it is a complete path. Use it as it is.
10245         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
10246 $as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
10247         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
10248 $as_echo_n "checking for TOUCH... " >&6; }
10249         if test ! -x "$tool_specified"; then
10250           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10251 $as_echo "not found" >&6; }
10252           as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
10253         fi
10254         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10255 $as_echo "$tool_specified" >&6; }
10256       fi
10257     fi
10258   fi
10259 
10260 
10261 
10262   if test "x$TOUCH" = x; then
10263     as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
10264   fi
10265 
10266 
10267 
10268 
10269 
10270   # Publish this variable in the help.
10271 
10272 
10273   if test "x$TR" = x; then
10274     # The variable is not set by user, try to locate tool using the code snippet
10275     for ac_prog in tr
10276 do
10277   # Extract the first word of "$ac_prog", so it can be a program name with args.
10278 set dummy $ac_prog; ac_word=$2
10279 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10280 $as_echo_n "checking for $ac_word... " >&6; }
10281 if ${ac_cv_path_TR+:} false; then :
10282   $as_echo_n "(cached) " >&6
10283 else
10284   case $TR in
10285   [\\/]* | ?:[\\/]*)
10286   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10287   ;;
10288   *)
10289   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10290 for as_dir in $PATH
10291 do
10292   IFS=$as_save_IFS
10293   test -z "$as_dir" && as_dir=.
10294     for ac_exec_ext in '' $ac_executable_extensions; do
10295   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10296     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10297     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10298     break 2
10299   fi
10300 done
10301   done
10302 IFS=$as_save_IFS
10303 
10304   ;;
10305 esac
10306 fi
10307 TR=$ac_cv_path_TR
10308 if test -n "$TR"; then
10309   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10310 $as_echo "$TR" >&6; }
10311 else
10312   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10313 $as_echo "no" >&6; }
10314 fi
10315 
10316 
10317   test -n "$TR" && break
10318 done
10319 
10320   else
10321     # The variable is set, but is it from the command line or the environment?
10322 
10323     # Try to remove the string !TR! from our list.
10324     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
10325     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10326       # If it failed, the variable was not from the command line. Ignore it,
10327       # but warn the user (except for BASH, which is always set by the calling BASH).
10328       if test "xTR" != xBASH; then
10329         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
10330 $as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
10331       fi
10332       # Try to locate tool using the code snippet
10333       for ac_prog in tr
10334 do
10335   # Extract the first word of "$ac_prog", so it can be a program name with args.
10336 set dummy $ac_prog; ac_word=$2
10337 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10338 $as_echo_n "checking for $ac_word... " >&6; }
10339 if ${ac_cv_path_TR+:} false; then :
10340   $as_echo_n "(cached) " >&6
10341 else
10342   case $TR in
10343   [\\/]* | ?:[\\/]*)
10344   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10345   ;;
10346   *)
10347   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10348 for as_dir in $PATH
10349 do
10350   IFS=$as_save_IFS
10351   test -z "$as_dir" && as_dir=.
10352     for ac_exec_ext in '' $ac_executable_extensions; do
10353   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10354     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10355     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10356     break 2
10357   fi
10358 done
10359   done
10360 IFS=$as_save_IFS
10361 
10362   ;;
10363 esac
10364 fi
10365 TR=$ac_cv_path_TR
10366 if test -n "$TR"; then
10367   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10368 $as_echo "$TR" >&6; }
10369 else
10370   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10371 $as_echo "no" >&6; }
10372 fi
10373 
10374 
10375   test -n "$TR" && break
10376 done
10377 
10378     else
10379       # If it succeeded, then it was overridden by the user. We will use it
10380       # for the tool.
10381 
10382       # First remove it from the list of overridden variables, so we can test
10383       # for unknown variables in the end.
10384       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10385 
10386       # Check if the provided tool contains a complete path.
10387       tool_specified="$TR"
10388       tool_basename="${tool_specified##*/}"
10389       if test "x$tool_basename" = "x$tool_specified"; then
10390         # A command without a complete path is provided, search $PATH.
10391         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
10392 $as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
10393         # Extract the first word of "$tool_basename", so it can be a program name with args.
10394 set dummy $tool_basename; ac_word=$2
10395 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10396 $as_echo_n "checking for $ac_word... " >&6; }
10397 if ${ac_cv_path_TR+:} false; then :
10398   $as_echo_n "(cached) " >&6
10399 else
10400   case $TR in
10401   [\\/]* | ?:[\\/]*)
10402   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10403   ;;
10404   *)
10405   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10406 for as_dir in $PATH
10407 do
10408   IFS=$as_save_IFS
10409   test -z "$as_dir" && as_dir=.
10410     for ac_exec_ext in '' $ac_executable_extensions; do
10411   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10412     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10413     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10414     break 2
10415   fi
10416 done
10417   done
10418 IFS=$as_save_IFS
10419 
10420   ;;
10421 esac
10422 fi
10423 TR=$ac_cv_path_TR
10424 if test -n "$TR"; then
10425   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10426 $as_echo "$TR" >&6; }
10427 else
10428   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10429 $as_echo "no" >&6; }
10430 fi
10431 
10432 
10433         if test "x$TR" = x; then
10434           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10435         fi
10436       else
10437         # Otherwise we believe it is a complete path. Use it as it is.
10438         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
10439 $as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
10440         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
10441 $as_echo_n "checking for TR... " >&6; }
10442         if test ! -x "$tool_specified"; then
10443           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10444 $as_echo "not found" >&6; }
10445           as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
10446         fi
10447         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10448 $as_echo "$tool_specified" >&6; }
10449       fi
10450     fi
10451   fi
10452 
10453 
10454 
10455   if test "x$TR" = x; then
10456     as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
10457   fi
10458 
10459 
10460 
10461 
10462 
10463   # Publish this variable in the help.
10464 
10465 
10466   if test "x$UNAME" = x; then
10467     # The variable is not set by user, try to locate tool using the code snippet
10468     for ac_prog in uname
10469 do
10470   # Extract the first word of "$ac_prog", so it can be a program name with args.
10471 set dummy $ac_prog; ac_word=$2
10472 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10473 $as_echo_n "checking for $ac_word... " >&6; }
10474 if ${ac_cv_path_UNAME+:} false; then :
10475   $as_echo_n "(cached) " >&6
10476 else
10477   case $UNAME in
10478   [\\/]* | ?:[\\/]*)
10479   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10480   ;;
10481   *)
10482   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10483 for as_dir in $PATH
10484 do
10485   IFS=$as_save_IFS
10486   test -z "$as_dir" && as_dir=.
10487     for ac_exec_ext in '' $ac_executable_extensions; do
10488   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10489     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10490     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10491     break 2
10492   fi
10493 done
10494   done
10495 IFS=$as_save_IFS
10496 
10497   ;;
10498 esac
10499 fi
10500 UNAME=$ac_cv_path_UNAME
10501 if test -n "$UNAME"; then
10502   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10503 $as_echo "$UNAME" >&6; }
10504 else
10505   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10506 $as_echo "no" >&6; }
10507 fi
10508 
10509 
10510   test -n "$UNAME" && break
10511 done
10512 
10513   else
10514     # The variable is set, but is it from the command line or the environment?
10515 
10516     # Try to remove the string !UNAME! from our list.
10517     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
10518     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10519       # If it failed, the variable was not from the command line. Ignore it,
10520       # but warn the user (except for BASH, which is always set by the calling BASH).
10521       if test "xUNAME" != xBASH; then
10522         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
10523 $as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
10524       fi
10525       # Try to locate tool using the code snippet
10526       for ac_prog in uname
10527 do
10528   # Extract the first word of "$ac_prog", so it can be a program name with args.
10529 set dummy $ac_prog; ac_word=$2
10530 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10531 $as_echo_n "checking for $ac_word... " >&6; }
10532 if ${ac_cv_path_UNAME+:} false; then :
10533   $as_echo_n "(cached) " >&6
10534 else
10535   case $UNAME in
10536   [\\/]* | ?:[\\/]*)
10537   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10538   ;;
10539   *)
10540   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10541 for as_dir in $PATH
10542 do
10543   IFS=$as_save_IFS
10544   test -z "$as_dir" && as_dir=.
10545     for ac_exec_ext in '' $ac_executable_extensions; do
10546   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10547     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10548     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10549     break 2
10550   fi
10551 done
10552   done
10553 IFS=$as_save_IFS
10554 
10555   ;;
10556 esac
10557 fi
10558 UNAME=$ac_cv_path_UNAME
10559 if test -n "$UNAME"; then
10560   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10561 $as_echo "$UNAME" >&6; }
10562 else
10563   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10564 $as_echo "no" >&6; }
10565 fi
10566 
10567 
10568   test -n "$UNAME" && break
10569 done
10570 
10571     else
10572       # If it succeeded, then it was overridden by the user. We will use it
10573       # for the tool.
10574 
10575       # First remove it from the list of overridden variables, so we can test
10576       # for unknown variables in the end.
10577       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10578 
10579       # Check if the provided tool contains a complete path.
10580       tool_specified="$UNAME"
10581       tool_basename="${tool_specified##*/}"
10582       if test "x$tool_basename" = "x$tool_specified"; then
10583         # A command without a complete path is provided, search $PATH.
10584         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
10585 $as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
10586         # Extract the first word of "$tool_basename", so it can be a program name with args.
10587 set dummy $tool_basename; ac_word=$2
10588 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10589 $as_echo_n "checking for $ac_word... " >&6; }
10590 if ${ac_cv_path_UNAME+:} false; then :
10591   $as_echo_n "(cached) " >&6
10592 else
10593   case $UNAME in
10594   [\\/]* | ?:[\\/]*)
10595   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10596   ;;
10597   *)
10598   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10599 for as_dir in $PATH
10600 do
10601   IFS=$as_save_IFS
10602   test -z "$as_dir" && as_dir=.
10603     for ac_exec_ext in '' $ac_executable_extensions; do
10604   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10605     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10606     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10607     break 2
10608   fi
10609 done
10610   done
10611 IFS=$as_save_IFS
10612 
10613   ;;
10614 esac
10615 fi
10616 UNAME=$ac_cv_path_UNAME
10617 if test -n "$UNAME"; then
10618   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10619 $as_echo "$UNAME" >&6; }
10620 else
10621   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10622 $as_echo "no" >&6; }
10623 fi
10624 
10625 
10626         if test "x$UNAME" = x; then
10627           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10628         fi
10629       else
10630         # Otherwise we believe it is a complete path. Use it as it is.
10631         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
10632 $as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
10633         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
10634 $as_echo_n "checking for UNAME... " >&6; }
10635         if test ! -x "$tool_specified"; then
10636           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10637 $as_echo "not found" >&6; }
10638           as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
10639         fi
10640         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10641 $as_echo "$tool_specified" >&6; }
10642       fi
10643     fi
10644   fi
10645 
10646 
10647 
10648   if test "x$UNAME" = x; then
10649     as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
10650   fi
10651 
10652 
10653 
10654 
10655 
10656   # Publish this variable in the help.
10657 
10658 
10659   if test "x$UNIQ" = x; then
10660     # The variable is not set by user, try to locate tool using the code snippet
10661     for ac_prog in uniq
10662 do
10663   # Extract the first word of "$ac_prog", so it can be a program name with args.
10664 set dummy $ac_prog; ac_word=$2
10665 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10666 $as_echo_n "checking for $ac_word... " >&6; }
10667 if ${ac_cv_path_UNIQ+:} false; then :
10668   $as_echo_n "(cached) " >&6
10669 else
10670   case $UNIQ in
10671   [\\/]* | ?:[\\/]*)
10672   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10673   ;;
10674   *)
10675   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10676 for as_dir in $PATH
10677 do
10678   IFS=$as_save_IFS
10679   test -z "$as_dir" && as_dir=.
10680     for ac_exec_ext in '' $ac_executable_extensions; do
10681   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10682     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10683     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10684     break 2
10685   fi
10686 done
10687   done
10688 IFS=$as_save_IFS
10689 
10690   ;;
10691 esac
10692 fi
10693 UNIQ=$ac_cv_path_UNIQ
10694 if test -n "$UNIQ"; then
10695   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10696 $as_echo "$UNIQ" >&6; }
10697 else
10698   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10699 $as_echo "no" >&6; }
10700 fi
10701 
10702 
10703   test -n "$UNIQ" && break
10704 done
10705 
10706   else
10707     # The variable is set, but is it from the command line or the environment?
10708 
10709     # Try to remove the string !UNIQ! from our list.
10710     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
10711     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10712       # If it failed, the variable was not from the command line. Ignore it,
10713       # but warn the user (except for BASH, which is always set by the calling BASH).
10714       if test "xUNIQ" != xBASH; then
10715         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
10716 $as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
10717       fi
10718       # Try to locate tool using the code snippet
10719       for ac_prog in uniq
10720 do
10721   # Extract the first word of "$ac_prog", so it can be a program name with args.
10722 set dummy $ac_prog; ac_word=$2
10723 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10724 $as_echo_n "checking for $ac_word... " >&6; }
10725 if ${ac_cv_path_UNIQ+:} false; then :
10726   $as_echo_n "(cached) " >&6
10727 else
10728   case $UNIQ in
10729   [\\/]* | ?:[\\/]*)
10730   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10731   ;;
10732   *)
10733   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10734 for as_dir in $PATH
10735 do
10736   IFS=$as_save_IFS
10737   test -z "$as_dir" && as_dir=.
10738     for ac_exec_ext in '' $ac_executable_extensions; do
10739   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10740     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10741     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10742     break 2
10743   fi
10744 done
10745   done
10746 IFS=$as_save_IFS
10747 
10748   ;;
10749 esac
10750 fi
10751 UNIQ=$ac_cv_path_UNIQ
10752 if test -n "$UNIQ"; then
10753   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10754 $as_echo "$UNIQ" >&6; }
10755 else
10756   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10757 $as_echo "no" >&6; }
10758 fi
10759 
10760 
10761   test -n "$UNIQ" && break
10762 done
10763 
10764     else
10765       # If it succeeded, then it was overridden by the user. We will use it
10766       # for the tool.
10767 
10768       # First remove it from the list of overridden variables, so we can test
10769       # for unknown variables in the end.
10770       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10771 
10772       # Check if the provided tool contains a complete path.
10773       tool_specified="$UNIQ"
10774       tool_basename="${tool_specified##*/}"
10775       if test "x$tool_basename" = "x$tool_specified"; then
10776         # A command without a complete path is provided, search $PATH.
10777         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
10778 $as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
10779         # Extract the first word of "$tool_basename", so it can be a program name with args.
10780 set dummy $tool_basename; ac_word=$2
10781 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10782 $as_echo_n "checking for $ac_word... " >&6; }
10783 if ${ac_cv_path_UNIQ+:} false; then :
10784   $as_echo_n "(cached) " >&6
10785 else
10786   case $UNIQ in
10787   [\\/]* | ?:[\\/]*)
10788   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10789   ;;
10790   *)
10791   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10792 for as_dir in $PATH
10793 do
10794   IFS=$as_save_IFS
10795   test -z "$as_dir" && as_dir=.
10796     for ac_exec_ext in '' $ac_executable_extensions; do
10797   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10798     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10799     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10800     break 2
10801   fi
10802 done
10803   done
10804 IFS=$as_save_IFS
10805 
10806   ;;
10807 esac
10808 fi
10809 UNIQ=$ac_cv_path_UNIQ
10810 if test -n "$UNIQ"; then
10811   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10812 $as_echo "$UNIQ" >&6; }
10813 else
10814   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10815 $as_echo "no" >&6; }
10816 fi
10817 
10818 
10819         if test "x$UNIQ" = x; then
10820           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10821         fi
10822       else
10823         # Otherwise we believe it is a complete path. Use it as it is.
10824         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
10825 $as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
10826         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
10827 $as_echo_n "checking for UNIQ... " >&6; }
10828         if test ! -x "$tool_specified"; then
10829           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10830 $as_echo "not found" >&6; }
10831           as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
10832         fi
10833         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10834 $as_echo "$tool_specified" >&6; }
10835       fi
10836     fi
10837   fi
10838 
10839 
10840 
10841   if test "x$UNIQ" = x; then
10842     as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
10843   fi
10844 
10845 
10846 
10847 
10848 
10849   # Publish this variable in the help.
10850 
10851 
10852   if test "x$WC" = x; then
10853     # The variable is not set by user, try to locate tool using the code snippet
10854     for ac_prog in wc
10855 do
10856   # Extract the first word of "$ac_prog", so it can be a program name with args.
10857 set dummy $ac_prog; ac_word=$2
10858 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10859 $as_echo_n "checking for $ac_word... " >&6; }
10860 if ${ac_cv_path_WC+:} false; then :
10861   $as_echo_n "(cached) " >&6
10862 else
10863   case $WC in
10864   [\\/]* | ?:[\\/]*)
10865   ac_cv_path_WC="$WC" # Let the user override the test with a path.
10866   ;;
10867   *)
10868   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10869 for as_dir in $PATH
10870 do
10871   IFS=$as_save_IFS
10872   test -z "$as_dir" && as_dir=.
10873     for ac_exec_ext in '' $ac_executable_extensions; do
10874   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10875     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10876     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10877     break 2
10878   fi
10879 done
10880   done
10881 IFS=$as_save_IFS
10882 
10883   ;;
10884 esac
10885 fi
10886 WC=$ac_cv_path_WC
10887 if test -n "$WC"; then
10888   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10889 $as_echo "$WC" >&6; }
10890 else
10891   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10892 $as_echo "no" >&6; }
10893 fi
10894 
10895 
10896   test -n "$WC" && break
10897 done
10898 
10899   else
10900     # The variable is set, but is it from the command line or the environment?
10901 
10902     # Try to remove the string !WC! from our list.
10903     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
10904     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10905       # If it failed, the variable was not from the command line. Ignore it,
10906       # but warn the user (except for BASH, which is always set by the calling BASH).
10907       if test "xWC" != xBASH; then
10908         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
10909 $as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
10910       fi
10911       # Try to locate tool using the code snippet
10912       for ac_prog in wc
10913 do
10914   # Extract the first word of "$ac_prog", so it can be a program name with args.
10915 set dummy $ac_prog; ac_word=$2
10916 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10917 $as_echo_n "checking for $ac_word... " >&6; }
10918 if ${ac_cv_path_WC+:} false; then :
10919   $as_echo_n "(cached) " >&6
10920 else
10921   case $WC in
10922   [\\/]* | ?:[\\/]*)
10923   ac_cv_path_WC="$WC" # Let the user override the test with a path.
10924   ;;
10925   *)
10926   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10927 for as_dir in $PATH
10928 do
10929   IFS=$as_save_IFS
10930   test -z "$as_dir" && as_dir=.
10931     for ac_exec_ext in '' $ac_executable_extensions; do
10932   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10933     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10934     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10935     break 2
10936   fi
10937 done
10938   done
10939 IFS=$as_save_IFS
10940 
10941   ;;
10942 esac
10943 fi
10944 WC=$ac_cv_path_WC
10945 if test -n "$WC"; then
10946   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10947 $as_echo "$WC" >&6; }
10948 else
10949   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10950 $as_echo "no" >&6; }
10951 fi
10952 
10953 
10954   test -n "$WC" && break
10955 done
10956 
10957     else
10958       # If it succeeded, then it was overridden by the user. We will use it
10959       # for the tool.
10960 
10961       # First remove it from the list of overridden variables, so we can test
10962       # for unknown variables in the end.
10963       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10964 
10965       # Check if the provided tool contains a complete path.
10966       tool_specified="$WC"
10967       tool_basename="${tool_specified##*/}"
10968       if test "x$tool_basename" = "x$tool_specified"; then
10969         # A command without a complete path is provided, search $PATH.
10970         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
10971 $as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
10972         # Extract the first word of "$tool_basename", so it can be a program name with args.
10973 set dummy $tool_basename; ac_word=$2
10974 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10975 $as_echo_n "checking for $ac_word... " >&6; }
10976 if ${ac_cv_path_WC+:} false; then :
10977   $as_echo_n "(cached) " >&6
10978 else
10979   case $WC in
10980   [\\/]* | ?:[\\/]*)
10981   ac_cv_path_WC="$WC" # Let the user override the test with a path.
10982   ;;
10983   *)
10984   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10985 for as_dir in $PATH
10986 do
10987   IFS=$as_save_IFS
10988   test -z "$as_dir" && as_dir=.
10989     for ac_exec_ext in '' $ac_executable_extensions; do
10990   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10991     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10992     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10993     break 2
10994   fi
10995 done
10996   done
10997 IFS=$as_save_IFS
10998 
10999   ;;
11000 esac
11001 fi
11002 WC=$ac_cv_path_WC
11003 if test -n "$WC"; then
11004   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
11005 $as_echo "$WC" >&6; }
11006 else
11007   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11008 $as_echo "no" >&6; }
11009 fi
11010 
11011 
11012         if test "x$WC" = x; then
11013           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11014         fi
11015       else
11016         # Otherwise we believe it is a complete path. Use it as it is.
11017         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
11018 $as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
11019         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
11020 $as_echo_n "checking for WC... " >&6; }
11021         if test ! -x "$tool_specified"; then
11022           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11023 $as_echo "not found" >&6; }
11024           as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
11025         fi
11026         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11027 $as_echo "$tool_specified" >&6; }
11028       fi
11029     fi
11030   fi
11031 
11032 
11033 
11034   if test "x$WC" = x; then
11035     as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
11036   fi
11037 
11038 
11039 
11040 
11041 
11042   # Publish this variable in the help.
11043 
11044 
11045   if test "x$WHICH" = x; then
11046     # The variable is not set by user, try to locate tool using the code snippet
11047     for ac_prog in which
11048 do
11049   # Extract the first word of "$ac_prog", so it can be a program name with args.
11050 set dummy $ac_prog; ac_word=$2
11051 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11052 $as_echo_n "checking for $ac_word... " >&6; }
11053 if ${ac_cv_path_WHICH+:} false; then :
11054   $as_echo_n "(cached) " >&6
11055 else
11056   case $WHICH in
11057   [\\/]* | ?:[\\/]*)
11058   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11059   ;;
11060   *)
11061   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11062 for as_dir in $PATH
11063 do
11064   IFS=$as_save_IFS
11065   test -z "$as_dir" && as_dir=.
11066     for ac_exec_ext in '' $ac_executable_extensions; do
11067   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11068     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11069     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11070     break 2
11071   fi
11072 done
11073   done
11074 IFS=$as_save_IFS
11075 
11076   ;;
11077 esac
11078 fi
11079 WHICH=$ac_cv_path_WHICH
11080 if test -n "$WHICH"; then
11081   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11082 $as_echo "$WHICH" >&6; }
11083 else
11084   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11085 $as_echo "no" >&6; }
11086 fi
11087 
11088 
11089   test -n "$WHICH" && break
11090 done
11091 
11092   else
11093     # The variable is set, but is it from the command line or the environment?
11094 
11095     # Try to remove the string !WHICH! from our list.
11096     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
11097     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11098       # If it failed, the variable was not from the command line. Ignore it,
11099       # but warn the user (except for BASH, which is always set by the calling BASH).
11100       if test "xWHICH" != xBASH; then
11101         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
11102 $as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
11103       fi
11104       # Try to locate tool using the code snippet
11105       for ac_prog in which
11106 do
11107   # Extract the first word of "$ac_prog", so it can be a program name with args.
11108 set dummy $ac_prog; ac_word=$2
11109 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11110 $as_echo_n "checking for $ac_word... " >&6; }
11111 if ${ac_cv_path_WHICH+:} false; then :
11112   $as_echo_n "(cached) " >&6
11113 else
11114   case $WHICH in
11115   [\\/]* | ?:[\\/]*)
11116   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11117   ;;
11118   *)
11119   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11120 for as_dir in $PATH
11121 do
11122   IFS=$as_save_IFS
11123   test -z "$as_dir" && as_dir=.
11124     for ac_exec_ext in '' $ac_executable_extensions; do
11125   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11126     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11127     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11128     break 2
11129   fi
11130 done
11131   done
11132 IFS=$as_save_IFS
11133 
11134   ;;
11135 esac
11136 fi
11137 WHICH=$ac_cv_path_WHICH
11138 if test -n "$WHICH"; then
11139   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11140 $as_echo "$WHICH" >&6; }
11141 else
11142   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11143 $as_echo "no" >&6; }
11144 fi
11145 
11146 
11147   test -n "$WHICH" && break
11148 done
11149 
11150     else
11151       # If it succeeded, then it was overridden by the user. We will use it
11152       # for the tool.
11153 
11154       # First remove it from the list of overridden variables, so we can test
11155       # for unknown variables in the end.
11156       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11157 
11158       # Check if the provided tool contains a complete path.
11159       tool_specified="$WHICH"
11160       tool_basename="${tool_specified##*/}"
11161       if test "x$tool_basename" = "x$tool_specified"; then
11162         # A command without a complete path is provided, search $PATH.
11163         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
11164 $as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
11165         # Extract the first word of "$tool_basename", so it can be a program name with args.
11166 set dummy $tool_basename; ac_word=$2
11167 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11168 $as_echo_n "checking for $ac_word... " >&6; }
11169 if ${ac_cv_path_WHICH+:} false; then :
11170   $as_echo_n "(cached) " >&6
11171 else
11172   case $WHICH in
11173   [\\/]* | ?:[\\/]*)
11174   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11175   ;;
11176   *)
11177   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11178 for as_dir in $PATH
11179 do
11180   IFS=$as_save_IFS
11181   test -z "$as_dir" && as_dir=.
11182     for ac_exec_ext in '' $ac_executable_extensions; do
11183   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11184     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11185     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11186     break 2
11187   fi
11188 done
11189   done
11190 IFS=$as_save_IFS
11191 
11192   ;;
11193 esac
11194 fi
11195 WHICH=$ac_cv_path_WHICH
11196 if test -n "$WHICH"; then
11197   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11198 $as_echo "$WHICH" >&6; }
11199 else
11200   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11201 $as_echo "no" >&6; }
11202 fi
11203 
11204 
11205         if test "x$WHICH" = x; then
11206           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11207         fi
11208       else
11209         # Otherwise we believe it is a complete path. Use it as it is.
11210         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
11211 $as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
11212         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
11213 $as_echo_n "checking for WHICH... " >&6; }
11214         if test ! -x "$tool_specified"; then
11215           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11216 $as_echo "not found" >&6; }
11217           as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
11218         fi
11219         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11220 $as_echo "$tool_specified" >&6; }
11221       fi
11222     fi
11223   fi
11224 
11225 
11226 
11227   if test "x$WHICH" = x; then
11228     as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
11229   fi
11230 
11231 
11232 
11233 
11234 
11235   # Publish this variable in the help.
11236 
11237 
11238   if test "x$XARGS" = x; then
11239     # The variable is not set by user, try to locate tool using the code snippet
11240     for ac_prog in xargs
11241 do
11242   # Extract the first word of "$ac_prog", so it can be a program name with args.
11243 set dummy $ac_prog; ac_word=$2
11244 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11245 $as_echo_n "checking for $ac_word... " >&6; }
11246 if ${ac_cv_path_XARGS+:} false; then :
11247   $as_echo_n "(cached) " >&6
11248 else
11249   case $XARGS in
11250   [\\/]* | ?:[\\/]*)
11251   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11252   ;;
11253   *)
11254   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11255 for as_dir in $PATH
11256 do
11257   IFS=$as_save_IFS
11258   test -z "$as_dir" && as_dir=.
11259     for ac_exec_ext in '' $ac_executable_extensions; do
11260   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11261     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11262     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11263     break 2
11264   fi
11265 done
11266   done
11267 IFS=$as_save_IFS
11268 
11269   ;;
11270 esac
11271 fi
11272 XARGS=$ac_cv_path_XARGS
11273 if test -n "$XARGS"; then
11274   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11275 $as_echo "$XARGS" >&6; }
11276 else
11277   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11278 $as_echo "no" >&6; }
11279 fi
11280 
11281 
11282   test -n "$XARGS" && break
11283 done
11284 
11285   else
11286     # The variable is set, but is it from the command line or the environment?
11287 
11288     # Try to remove the string !XARGS! from our list.
11289     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
11290     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11291       # If it failed, the variable was not from the command line. Ignore it,
11292       # but warn the user (except for BASH, which is always set by the calling BASH).
11293       if test "xXARGS" != xBASH; then
11294         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
11295 $as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
11296       fi
11297       # Try to locate tool using the code snippet
11298       for ac_prog in xargs
11299 do
11300   # Extract the first word of "$ac_prog", so it can be a program name with args.
11301 set dummy $ac_prog; ac_word=$2
11302 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11303 $as_echo_n "checking for $ac_word... " >&6; }
11304 if ${ac_cv_path_XARGS+:} false; then :
11305   $as_echo_n "(cached) " >&6
11306 else
11307   case $XARGS in
11308   [\\/]* | ?:[\\/]*)
11309   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11310   ;;
11311   *)
11312   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11313 for as_dir in $PATH
11314 do
11315   IFS=$as_save_IFS
11316   test -z "$as_dir" && as_dir=.
11317     for ac_exec_ext in '' $ac_executable_extensions; do
11318   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11319     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11320     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11321     break 2
11322   fi
11323 done
11324   done
11325 IFS=$as_save_IFS
11326 
11327   ;;
11328 esac
11329 fi
11330 XARGS=$ac_cv_path_XARGS
11331 if test -n "$XARGS"; then
11332   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11333 $as_echo "$XARGS" >&6; }
11334 else
11335   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11336 $as_echo "no" >&6; }
11337 fi
11338 
11339 
11340   test -n "$XARGS" && break
11341 done
11342 
11343     else
11344       # If it succeeded, then it was overridden by the user. We will use it
11345       # for the tool.
11346 
11347       # First remove it from the list of overridden variables, so we can test
11348       # for unknown variables in the end.
11349       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11350 
11351       # Check if the provided tool contains a complete path.
11352       tool_specified="$XARGS"
11353       tool_basename="${tool_specified##*/}"
11354       if test "x$tool_basename" = "x$tool_specified"; then
11355         # A command without a complete path is provided, search $PATH.
11356         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
11357 $as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
11358         # Extract the first word of "$tool_basename", so it can be a program name with args.
11359 set dummy $tool_basename; ac_word=$2
11360 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11361 $as_echo_n "checking for $ac_word... " >&6; }
11362 if ${ac_cv_path_XARGS+:} false; then :
11363   $as_echo_n "(cached) " >&6
11364 else
11365   case $XARGS in
11366   [\\/]* | ?:[\\/]*)
11367   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11368   ;;
11369   *)
11370   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11371 for as_dir in $PATH
11372 do
11373   IFS=$as_save_IFS
11374   test -z "$as_dir" && as_dir=.
11375     for ac_exec_ext in '' $ac_executable_extensions; do
11376   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11377     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11378     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11379     break 2
11380   fi
11381 done
11382   done
11383 IFS=$as_save_IFS
11384 
11385   ;;
11386 esac
11387 fi
11388 XARGS=$ac_cv_path_XARGS
11389 if test -n "$XARGS"; then
11390   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11391 $as_echo "$XARGS" >&6; }
11392 else
11393   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11394 $as_echo "no" >&6; }
11395 fi
11396 
11397 
11398         if test "x$XARGS" = x; then
11399           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11400         fi
11401       else
11402         # Otherwise we believe it is a complete path. Use it as it is.
11403         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
11404 $as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
11405         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
11406 $as_echo_n "checking for XARGS... " >&6; }
11407         if test ! -x "$tool_specified"; then
11408           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11409 $as_echo "not found" >&6; }
11410           as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
11411         fi
11412         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11413 $as_echo "$tool_specified" >&6; }
11414       fi
11415     fi
11416   fi
11417 
11418 
11419 
11420   if test "x$XARGS" = x; then
11421     as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
11422   fi
11423 
11424 
11425 
11426   # Then required tools that require some special treatment.
11427 
11428 
11429   # Publish this variable in the help.
11430 
11431 
11432   if test "x$AWK" = x; then
11433     # The variable is not set by user, try to locate tool using the code snippet
11434     for ac_prog in gawk mawk nawk awk
11435 do
11436   # Extract the first word of "$ac_prog", so it can be a program name with args.
11437 set dummy $ac_prog; ac_word=$2
11438 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11439 $as_echo_n "checking for $ac_word... " >&6; }
11440 if ${ac_cv_prog_AWK+:} false; then :
11441   $as_echo_n "(cached) " >&6
11442 else
11443   if test -n "$AWK"; then
11444   ac_cv_prog_AWK="$AWK" # Let the user override the test.
11445 else
11446 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11447 for as_dir in $PATH
11448 do
11449   IFS=$as_save_IFS
11450   test -z "$as_dir" && as_dir=.
11451     for ac_exec_ext in '' $ac_executable_extensions; do
11452   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11453     ac_cv_prog_AWK="$ac_prog"
11454     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11455     break 2
11456   fi
11457 done
11458   done
11459 IFS=$as_save_IFS
11460 
11461 fi
11462 fi
11463 AWK=$ac_cv_prog_AWK
11464 if test -n "$AWK"; then
11465   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11466 $as_echo "$AWK" >&6; }
11467 else
11468   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11469 $as_echo "no" >&6; }
11470 fi
11471 
11472 
11473   test -n "$AWK" && break
11474 done
11475 
11476   else
11477     # The variable is set, but is it from the command line or the environment?
11478 
11479     # Try to remove the string !AWK! from our list.
11480     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
11481     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11482       # If it failed, the variable was not from the command line. Ignore it,
11483       # but warn the user (except for BASH, which is always set by the calling BASH).
11484       if test "xAWK" != xBASH; then
11485         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
11486 $as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
11487       fi
11488       # Try to locate tool using the code snippet
11489       for ac_prog in gawk mawk nawk awk
11490 do
11491   # Extract the first word of "$ac_prog", so it can be a program name with args.
11492 set dummy $ac_prog; ac_word=$2
11493 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11494 $as_echo_n "checking for $ac_word... " >&6; }
11495 if ${ac_cv_prog_AWK+:} false; then :
11496   $as_echo_n "(cached) " >&6
11497 else
11498   if test -n "$AWK"; then
11499   ac_cv_prog_AWK="$AWK" # Let the user override the test.
11500 else
11501 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11502 for as_dir in $PATH
11503 do
11504   IFS=$as_save_IFS
11505   test -z "$as_dir" && as_dir=.
11506     for ac_exec_ext in '' $ac_executable_extensions; do
11507   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11508     ac_cv_prog_AWK="$ac_prog"
11509     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11510     break 2
11511   fi
11512 done
11513   done
11514 IFS=$as_save_IFS
11515 
11516 fi
11517 fi
11518 AWK=$ac_cv_prog_AWK
11519 if test -n "$AWK"; then
11520   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11521 $as_echo "$AWK" >&6; }
11522 else
11523   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11524 $as_echo "no" >&6; }
11525 fi
11526 
11527 
11528   test -n "$AWK" && break
11529 done
11530 
11531     else
11532       # If it succeeded, then it was overridden by the user. We will use it
11533       # for the tool.
11534 
11535       # First remove it from the list of overridden variables, so we can test
11536       # for unknown variables in the end.
11537       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11538 
11539       # Check if the provided tool contains a complete path.
11540       tool_specified="$AWK"
11541       tool_basename="${tool_specified##*/}"
11542       if test "x$tool_basename" = "x$tool_specified"; then
11543         # A command without a complete path is provided, search $PATH.
11544         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
11545 $as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
11546         # Extract the first word of "$tool_basename", so it can be a program name with args.
11547 set dummy $tool_basename; ac_word=$2
11548 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11549 $as_echo_n "checking for $ac_word... " >&6; }
11550 if ${ac_cv_path_AWK+:} false; then :
11551   $as_echo_n "(cached) " >&6
11552 else
11553   case $AWK in
11554   [\\/]* | ?:[\\/]*)
11555   ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
11556   ;;
11557   *)
11558   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11559 for as_dir in $PATH
11560 do
11561   IFS=$as_save_IFS
11562   test -z "$as_dir" && as_dir=.
11563     for ac_exec_ext in '' $ac_executable_extensions; do
11564   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11565     ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
11566     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11567     break 2
11568   fi
11569 done
11570   done
11571 IFS=$as_save_IFS
11572 
11573   ;;
11574 esac
11575 fi
11576 AWK=$ac_cv_path_AWK
11577 if test -n "$AWK"; then
11578   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11579 $as_echo "$AWK" >&6; }
11580 else
11581   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11582 $as_echo "no" >&6; }
11583 fi
11584 
11585 
11586         if test "x$AWK" = x; then
11587           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11588         fi
11589       else
11590         # Otherwise we believe it is a complete path. Use it as it is.
11591         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
11592 $as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
11593         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
11594 $as_echo_n "checking for AWK... " >&6; }
11595         if test ! -x "$tool_specified"; then
11596           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11597 $as_echo "not found" >&6; }
11598           as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
11599         fi
11600         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11601 $as_echo "$tool_specified" >&6; }
11602       fi
11603     fi
11604   fi
11605 
11606 
11607   if test "x$AWK" = x; then
11608     as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
11609   fi
11610 
11611 
11612 
11613 
11614   # Publish this variable in the help.
11615 
11616 
11617   if test "x$GREP" = x; then
11618     # The variable is not set by user, try to locate tool using the code snippet
11619     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11620 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11621 if ${ac_cv_path_GREP+:} false; then :
11622   $as_echo_n "(cached) " >&6
11623 else
11624   if test -z "$GREP"; then
11625   ac_path_GREP_found=false
11626   # Loop through the user's path and test for each of PROGNAME-LIST
11627   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11628 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11629 do
11630   IFS=$as_save_IFS
11631   test -z "$as_dir" && as_dir=.
11632     for ac_prog in grep ggrep; do
11633     for ac_exec_ext in '' $ac_executable_extensions; do
11634       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11635       as_fn_executable_p "$ac_path_GREP" || continue
11636 # Check for GNU ac_path_GREP and select it if it is found.
11637   # Check for GNU $ac_path_GREP
11638 case `"$ac_path_GREP" --version 2>&1` in
11639 *GNU*)
11640   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11641 *)
11642   ac_count=0
11643   $as_echo_n 0123456789 >"conftest.in"
11644   while :
11645   do
11646     cat "conftest.in" "conftest.in" >"conftest.tmp"
11647     mv "conftest.tmp" "conftest.in"
11648     cp "conftest.in" "conftest.nl"
11649     $as_echo 'GREP' >> "conftest.nl"
11650     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11651     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11652     as_fn_arith $ac_count + 1 && ac_count=$as_val
11653     if test $ac_count -gt ${ac_path_GREP_max-0}; then
11654       # Best one so far, save it but keep looking for a better one
11655       ac_cv_path_GREP="$ac_path_GREP"
11656       ac_path_GREP_max=$ac_count
11657     fi
11658     # 10*(2^10) chars as input seems more than enough
11659     test $ac_count -gt 10 && break
11660   done
11661   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11662 esac
11663 
11664       $ac_path_GREP_found && break 3
11665     done
11666   done
11667   done
11668 IFS=$as_save_IFS
11669   if test -z "$ac_cv_path_GREP"; then
11670     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11671   fi
11672 else
11673   ac_cv_path_GREP=$GREP
11674 fi
11675 
11676 fi
11677 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11678 $as_echo "$ac_cv_path_GREP" >&6; }
11679  GREP="$ac_cv_path_GREP"
11680 
11681 
11682   else
11683     # The variable is set, but is it from the command line or the environment?
11684 
11685     # Try to remove the string !GREP! from our list.
11686     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
11687     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11688       # If it failed, the variable was not from the command line. Ignore it,
11689       # but warn the user (except for BASH, which is always set by the calling BASH).
11690       if test "xGREP" != xBASH; then
11691         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
11692 $as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
11693       fi
11694       # Try to locate tool using the code snippet
11695       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11696 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11697 if ${ac_cv_path_GREP+:} false; then :
11698   $as_echo_n "(cached) " >&6
11699 else
11700   if test -z "$GREP"; then
11701   ac_path_GREP_found=false
11702   # Loop through the user's path and test for each of PROGNAME-LIST
11703   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11704 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11705 do
11706   IFS=$as_save_IFS
11707   test -z "$as_dir" && as_dir=.
11708     for ac_prog in grep ggrep; do
11709     for ac_exec_ext in '' $ac_executable_extensions; do
11710       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11711       as_fn_executable_p "$ac_path_GREP" || continue
11712 # Check for GNU ac_path_GREP and select it if it is found.
11713   # Check for GNU $ac_path_GREP
11714 case `"$ac_path_GREP" --version 2>&1` in
11715 *GNU*)
11716   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11717 *)
11718   ac_count=0
11719   $as_echo_n 0123456789 >"conftest.in"
11720   while :
11721   do
11722     cat "conftest.in" "conftest.in" >"conftest.tmp"
11723     mv "conftest.tmp" "conftest.in"
11724     cp "conftest.in" "conftest.nl"
11725     $as_echo 'GREP' >> "conftest.nl"
11726     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11727     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11728     as_fn_arith $ac_count + 1 && ac_count=$as_val
11729     if test $ac_count -gt ${ac_path_GREP_max-0}; then
11730       # Best one so far, save it but keep looking for a better one
11731       ac_cv_path_GREP="$ac_path_GREP"
11732       ac_path_GREP_max=$ac_count
11733     fi
11734     # 10*(2^10) chars as input seems more than enough
11735     test $ac_count -gt 10 && break
11736   done
11737   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11738 esac
11739 
11740       $ac_path_GREP_found && break 3
11741     done
11742   done
11743   done
11744 IFS=$as_save_IFS
11745   if test -z "$ac_cv_path_GREP"; then
11746     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11747   fi
11748 else
11749   ac_cv_path_GREP=$GREP
11750 fi
11751 
11752 fi
11753 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11754 $as_echo "$ac_cv_path_GREP" >&6; }
11755  GREP="$ac_cv_path_GREP"
11756 
11757 
11758     else
11759       # If it succeeded, then it was overridden by the user. We will use it
11760       # for the tool.
11761 
11762       # First remove it from the list of overridden variables, so we can test
11763       # for unknown variables in the end.
11764       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11765 
11766       # Check if the provided tool contains a complete path.
11767       tool_specified="$GREP"
11768       tool_basename="${tool_specified##*/}"
11769       if test "x$tool_basename" = "x$tool_specified"; then
11770         # A command without a complete path is provided, search $PATH.
11771         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
11772 $as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
11773         # Extract the first word of "$tool_basename", so it can be a program name with args.
11774 set dummy $tool_basename; ac_word=$2
11775 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11776 $as_echo_n "checking for $ac_word... " >&6; }
11777 if ${ac_cv_path_GREP+:} false; then :
11778   $as_echo_n "(cached) " >&6
11779 else
11780   case $GREP in
11781   [\\/]* | ?:[\\/]*)
11782   ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
11783   ;;
11784   *)
11785   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11786 for as_dir in $PATH
11787 do
11788   IFS=$as_save_IFS
11789   test -z "$as_dir" && as_dir=.
11790     for ac_exec_ext in '' $ac_executable_extensions; do
11791   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11792     ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
11793     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11794     break 2
11795   fi
11796 done
11797   done
11798 IFS=$as_save_IFS
11799 
11800   ;;
11801 esac
11802 fi
11803 GREP=$ac_cv_path_GREP
11804 if test -n "$GREP"; then
11805   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
11806 $as_echo "$GREP" >&6; }
11807 else
11808   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11809 $as_echo "no" >&6; }
11810 fi
11811 
11812 
11813         if test "x$GREP" = x; then
11814           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11815         fi
11816       else
11817         # Otherwise we believe it is a complete path. Use it as it is.
11818         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
11819 $as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
11820         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
11821 $as_echo_n "checking for GREP... " >&6; }
11822         if test ! -x "$tool_specified"; then
11823           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11824 $as_echo "not found" >&6; }
11825           as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
11826         fi
11827         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11828 $as_echo "$tool_specified" >&6; }
11829       fi
11830     fi
11831   fi
11832 
11833 
11834   if test "x$GREP" = x; then
11835     as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
11836   fi
11837 
11838 
11839 
11840 
11841   # Publish this variable in the help.
11842 
11843 
11844   if test "x$EGREP" = x; then
11845     # The variable is not set by user, try to locate tool using the code snippet
11846     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11847 $as_echo_n "checking for egrep... " >&6; }
11848 if ${ac_cv_path_EGREP+:} false; then :
11849   $as_echo_n "(cached) " >&6
11850 else
11851   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11852    then ac_cv_path_EGREP="$GREP -E"
11853    else
11854      if test -z "$EGREP"; then
11855   ac_path_EGREP_found=false
11856   # Loop through the user's path and test for each of PROGNAME-LIST
11857   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11858 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11859 do
11860   IFS=$as_save_IFS
11861   test -z "$as_dir" && as_dir=.
11862     for ac_prog in egrep; do
11863     for ac_exec_ext in '' $ac_executable_extensions; do
11864       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11865       as_fn_executable_p "$ac_path_EGREP" || continue
11866 # Check for GNU ac_path_EGREP and select it if it is found.
11867   # Check for GNU $ac_path_EGREP
11868 case `"$ac_path_EGREP" --version 2>&1` in
11869 *GNU*)
11870   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11871 *)
11872   ac_count=0
11873   $as_echo_n 0123456789 >"conftest.in"
11874   while :
11875   do
11876     cat "conftest.in" "conftest.in" >"conftest.tmp"
11877     mv "conftest.tmp" "conftest.in"
11878     cp "conftest.in" "conftest.nl"
11879     $as_echo 'EGREP' >> "conftest.nl"
11880     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11881     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11882     as_fn_arith $ac_count + 1 && ac_count=$as_val
11883     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11884       # Best one so far, save it but keep looking for a better one
11885       ac_cv_path_EGREP="$ac_path_EGREP"
11886       ac_path_EGREP_max=$ac_count
11887     fi
11888     # 10*(2^10) chars as input seems more than enough
11889     test $ac_count -gt 10 && break
11890   done
11891   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11892 esac
11893 
11894       $ac_path_EGREP_found && break 3
11895     done
11896   done
11897   done
11898 IFS=$as_save_IFS
11899   if test -z "$ac_cv_path_EGREP"; then
11900     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11901   fi
11902 else
11903   ac_cv_path_EGREP=$EGREP
11904 fi
11905 
11906    fi
11907 fi
11908 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11909 $as_echo "$ac_cv_path_EGREP" >&6; }
11910  EGREP="$ac_cv_path_EGREP"
11911 
11912 
11913   else
11914     # The variable is set, but is it from the command line or the environment?
11915 
11916     # Try to remove the string !EGREP! from our list.
11917     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
11918     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11919       # If it failed, the variable was not from the command line. Ignore it,
11920       # but warn the user (except for BASH, which is always set by the calling BASH).
11921       if test "xEGREP" != xBASH; then
11922         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
11923 $as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
11924       fi
11925       # Try to locate tool using the code snippet
11926       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11927 $as_echo_n "checking for egrep... " >&6; }
11928 if ${ac_cv_path_EGREP+:} false; then :
11929   $as_echo_n "(cached) " >&6
11930 else
11931   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11932    then ac_cv_path_EGREP="$GREP -E"
11933    else
11934      if test -z "$EGREP"; then
11935   ac_path_EGREP_found=false
11936   # Loop through the user's path and test for each of PROGNAME-LIST
11937   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11938 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11939 do
11940   IFS=$as_save_IFS
11941   test -z "$as_dir" && as_dir=.
11942     for ac_prog in egrep; do
11943     for ac_exec_ext in '' $ac_executable_extensions; do
11944       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11945       as_fn_executable_p "$ac_path_EGREP" || continue
11946 # Check for GNU ac_path_EGREP and select it if it is found.
11947   # Check for GNU $ac_path_EGREP
11948 case `"$ac_path_EGREP" --version 2>&1` in
11949 *GNU*)
11950   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11951 *)
11952   ac_count=0
11953   $as_echo_n 0123456789 >"conftest.in"
11954   while :
11955   do
11956     cat "conftest.in" "conftest.in" >"conftest.tmp"
11957     mv "conftest.tmp" "conftest.in"
11958     cp "conftest.in" "conftest.nl"
11959     $as_echo 'EGREP' >> "conftest.nl"
11960     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11961     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11962     as_fn_arith $ac_count + 1 && ac_count=$as_val
11963     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11964       # Best one so far, save it but keep looking for a better one
11965       ac_cv_path_EGREP="$ac_path_EGREP"
11966       ac_path_EGREP_max=$ac_count
11967     fi
11968     # 10*(2^10) chars as input seems more than enough
11969     test $ac_count -gt 10 && break
11970   done
11971   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11972 esac
11973 
11974       $ac_path_EGREP_found && break 3
11975     done
11976   done
11977   done
11978 IFS=$as_save_IFS
11979   if test -z "$ac_cv_path_EGREP"; then
11980     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11981   fi
11982 else
11983   ac_cv_path_EGREP=$EGREP
11984 fi
11985 
11986    fi
11987 fi
11988 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11989 $as_echo "$ac_cv_path_EGREP" >&6; }
11990  EGREP="$ac_cv_path_EGREP"
11991 
11992 
11993     else
11994       # If it succeeded, then it was overridden by the user. We will use it
11995       # for the tool.
11996 
11997       # First remove it from the list of overridden variables, so we can test
11998       # for unknown variables in the end.
11999       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12000 
12001       # Check if the provided tool contains a complete path.
12002       tool_specified="$EGREP"
12003       tool_basename="${tool_specified##*/}"
12004       if test "x$tool_basename" = "x$tool_specified"; then
12005         # A command without a complete path is provided, search $PATH.
12006         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
12007 $as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
12008         # Extract the first word of "$tool_basename", so it can be a program name with args.
12009 set dummy $tool_basename; ac_word=$2
12010 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12011 $as_echo_n "checking for $ac_word... " >&6; }
12012 if ${ac_cv_path_EGREP+:} false; then :
12013   $as_echo_n "(cached) " >&6
12014 else
12015   case $EGREP in
12016   [\\/]* | ?:[\\/]*)
12017   ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
12018   ;;
12019   *)
12020   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12021 for as_dir in $PATH
12022 do
12023   IFS=$as_save_IFS
12024   test -z "$as_dir" && as_dir=.
12025     for ac_exec_ext in '' $ac_executable_extensions; do
12026   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12027     ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
12028     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12029     break 2
12030   fi
12031 done
12032   done
12033 IFS=$as_save_IFS
12034 
12035   ;;
12036 esac
12037 fi
12038 EGREP=$ac_cv_path_EGREP
12039 if test -n "$EGREP"; then
12040   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
12041 $as_echo "$EGREP" >&6; }
12042 else
12043   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12044 $as_echo "no" >&6; }
12045 fi
12046 
12047 
12048         if test "x$EGREP" = x; then
12049           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12050         fi
12051       else
12052         # Otherwise we believe it is a complete path. Use it as it is.
12053         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
12054 $as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
12055         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
12056 $as_echo_n "checking for EGREP... " >&6; }
12057         if test ! -x "$tool_specified"; then
12058           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12059 $as_echo "not found" >&6; }
12060           as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12061         fi
12062         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12063 $as_echo "$tool_specified" >&6; }
12064       fi
12065     fi
12066   fi
12067 
12068 
12069   if test "x$EGREP" = x; then
12070     as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
12071   fi
12072 
12073 
12074 
12075 
12076   # Publish this variable in the help.
12077 
12078 
12079   if test "x$FGREP" = x; then
12080     # The variable is not set by user, try to locate tool using the code snippet
12081     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12082 $as_echo_n "checking for fgrep... " >&6; }
12083 if ${ac_cv_path_FGREP+:} false; then :
12084   $as_echo_n "(cached) " >&6
12085 else
12086   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12087    then ac_cv_path_FGREP="$GREP -F"
12088    else
12089      if test -z "$FGREP"; then
12090   ac_path_FGREP_found=false
12091   # Loop through the user's path and test for each of PROGNAME-LIST
12092   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12093 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12094 do
12095   IFS=$as_save_IFS
12096   test -z "$as_dir" && as_dir=.
12097     for ac_prog in fgrep; do
12098     for ac_exec_ext in '' $ac_executable_extensions; do
12099       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12100       as_fn_executable_p "$ac_path_FGREP" || continue
12101 # Check for GNU ac_path_FGREP and select it if it is found.
12102   # Check for GNU $ac_path_FGREP
12103 case `"$ac_path_FGREP" --version 2>&1` in
12104 *GNU*)
12105   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12106 *)
12107   ac_count=0
12108   $as_echo_n 0123456789 >"conftest.in"
12109   while :
12110   do
12111     cat "conftest.in" "conftest.in" >"conftest.tmp"
12112     mv "conftest.tmp" "conftest.in"
12113     cp "conftest.in" "conftest.nl"
12114     $as_echo 'FGREP' >> "conftest.nl"
12115     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12116     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12117     as_fn_arith $ac_count + 1 && ac_count=$as_val
12118     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12119       # Best one so far, save it but keep looking for a better one
12120       ac_cv_path_FGREP="$ac_path_FGREP"
12121       ac_path_FGREP_max=$ac_count
12122     fi
12123     # 10*(2^10) chars as input seems more than enough
12124     test $ac_count -gt 10 && break
12125   done
12126   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12127 esac
12128 
12129       $ac_path_FGREP_found && break 3
12130     done
12131   done
12132   done
12133 IFS=$as_save_IFS
12134   if test -z "$ac_cv_path_FGREP"; then
12135     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12136   fi
12137 else
12138   ac_cv_path_FGREP=$FGREP
12139 fi
12140 
12141    fi
12142 fi
12143 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12144 $as_echo "$ac_cv_path_FGREP" >&6; }
12145  FGREP="$ac_cv_path_FGREP"
12146 
12147 
12148   else
12149     # The variable is set, but is it from the command line or the environment?
12150 
12151     # Try to remove the string !FGREP! from our list.
12152     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
12153     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12154       # If it failed, the variable was not from the command line. Ignore it,
12155       # but warn the user (except for BASH, which is always set by the calling BASH).
12156       if test "xFGREP" != xBASH; then
12157         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
12158 $as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
12159       fi
12160       # Try to locate tool using the code snippet
12161       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12162 $as_echo_n "checking for fgrep... " >&6; }
12163 if ${ac_cv_path_FGREP+:} false; then :
12164   $as_echo_n "(cached) " >&6
12165 else
12166   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12167    then ac_cv_path_FGREP="$GREP -F"
12168    else
12169      if test -z "$FGREP"; then
12170   ac_path_FGREP_found=false
12171   # Loop through the user's path and test for each of PROGNAME-LIST
12172   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12173 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12174 do
12175   IFS=$as_save_IFS
12176   test -z "$as_dir" && as_dir=.
12177     for ac_prog in fgrep; do
12178     for ac_exec_ext in '' $ac_executable_extensions; do
12179       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12180       as_fn_executable_p "$ac_path_FGREP" || continue
12181 # Check for GNU ac_path_FGREP and select it if it is found.
12182   # Check for GNU $ac_path_FGREP
12183 case `"$ac_path_FGREP" --version 2>&1` in
12184 *GNU*)
12185   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12186 *)
12187   ac_count=0
12188   $as_echo_n 0123456789 >"conftest.in"
12189   while :
12190   do
12191     cat "conftest.in" "conftest.in" >"conftest.tmp"
12192     mv "conftest.tmp" "conftest.in"
12193     cp "conftest.in" "conftest.nl"
12194     $as_echo 'FGREP' >> "conftest.nl"
12195     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12196     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12197     as_fn_arith $ac_count + 1 && ac_count=$as_val
12198     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12199       # Best one so far, save it but keep looking for a better one
12200       ac_cv_path_FGREP="$ac_path_FGREP"
12201       ac_path_FGREP_max=$ac_count
12202     fi
12203     # 10*(2^10) chars as input seems more than enough
12204     test $ac_count -gt 10 && break
12205   done
12206   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12207 esac
12208 
12209       $ac_path_FGREP_found && break 3
12210     done
12211   done
12212   done
12213 IFS=$as_save_IFS
12214   if test -z "$ac_cv_path_FGREP"; then
12215     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12216   fi
12217 else
12218   ac_cv_path_FGREP=$FGREP
12219 fi
12220 
12221    fi
12222 fi
12223 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12224 $as_echo "$ac_cv_path_FGREP" >&6; }
12225  FGREP="$ac_cv_path_FGREP"
12226 
12227 
12228     else
12229       # If it succeeded, then it was overridden by the user. We will use it
12230       # for the tool.
12231 
12232       # First remove it from the list of overridden variables, so we can test
12233       # for unknown variables in the end.
12234       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12235 
12236       # Check if the provided tool contains a complete path.
12237       tool_specified="$FGREP"
12238       tool_basename="${tool_specified##*/}"
12239       if test "x$tool_basename" = "x$tool_specified"; then
12240         # A command without a complete path is provided, search $PATH.
12241         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
12242 $as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
12243         # Extract the first word of "$tool_basename", so it can be a program name with args.
12244 set dummy $tool_basename; ac_word=$2
12245 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12246 $as_echo_n "checking for $ac_word... " >&6; }
12247 if ${ac_cv_path_FGREP+:} false; then :
12248   $as_echo_n "(cached) " >&6
12249 else
12250   case $FGREP in
12251   [\\/]* | ?:[\\/]*)
12252   ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
12253   ;;
12254   *)
12255   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12256 for as_dir in $PATH
12257 do
12258   IFS=$as_save_IFS
12259   test -z "$as_dir" && as_dir=.
12260     for ac_exec_ext in '' $ac_executable_extensions; do
12261   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12262     ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
12263     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12264     break 2
12265   fi
12266 done
12267   done
12268 IFS=$as_save_IFS
12269 
12270   ;;
12271 esac
12272 fi
12273 FGREP=$ac_cv_path_FGREP
12274 if test -n "$FGREP"; then
12275   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
12276 $as_echo "$FGREP" >&6; }
12277 else
12278   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12279 $as_echo "no" >&6; }
12280 fi
12281 
12282 
12283         if test "x$FGREP" = x; then
12284           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12285         fi
12286       else
12287         # Otherwise we believe it is a complete path. Use it as it is.
12288         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
12289 $as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
12290         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
12291 $as_echo_n "checking for FGREP... " >&6; }
12292         if test ! -x "$tool_specified"; then
12293           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12294 $as_echo "not found" >&6; }
12295           as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12296         fi
12297         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12298 $as_echo "$tool_specified" >&6; }
12299       fi
12300     fi
12301   fi
12302 
12303 
12304   if test "x$FGREP" = x; then
12305     as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
12306   fi
12307 
12308 
12309 
12310 
12311   # Publish this variable in the help.
12312 
12313 
12314   if test "x$SED" = x; then
12315     # The variable is not set by user, try to locate tool using the code snippet
12316     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12317 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12318 if ${ac_cv_path_SED+:} false; then :
12319   $as_echo_n "(cached) " >&6
12320 else
12321             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12322      for ac_i in 1 2 3 4 5 6 7; do
12323        ac_script="$ac_script$as_nl$ac_script"
12324      done
12325      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12326      { ac_script=; unset ac_script;}
12327      if test -z "$SED"; then
12328   ac_path_SED_found=false
12329   # Loop through the user's path and test for each of PROGNAME-LIST
12330   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12331 for as_dir in $PATH
12332 do
12333   IFS=$as_save_IFS
12334   test -z "$as_dir" && as_dir=.
12335     for ac_prog in sed gsed; do
12336     for ac_exec_ext in '' $ac_executable_extensions; do
12337       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12338       as_fn_executable_p "$ac_path_SED" || continue
12339 # Check for GNU ac_path_SED and select it if it is found.
12340   # Check for GNU $ac_path_SED
12341 case `"$ac_path_SED" --version 2>&1` in
12342 *GNU*)
12343   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12344 *)
12345   ac_count=0
12346   $as_echo_n 0123456789 >"conftest.in"
12347   while :
12348   do
12349     cat "conftest.in" "conftest.in" >"conftest.tmp"
12350     mv "conftest.tmp" "conftest.in"
12351     cp "conftest.in" "conftest.nl"
12352     $as_echo '' >> "conftest.nl"
12353     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12354     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12355     as_fn_arith $ac_count + 1 && ac_count=$as_val
12356     if test $ac_count -gt ${ac_path_SED_max-0}; then
12357       # Best one so far, save it but keep looking for a better one
12358       ac_cv_path_SED="$ac_path_SED"
12359       ac_path_SED_max=$ac_count
12360     fi
12361     # 10*(2^10) chars as input seems more than enough
12362     test $ac_count -gt 10 && break
12363   done
12364   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12365 esac
12366 
12367       $ac_path_SED_found && break 3
12368     done
12369   done
12370   done
12371 IFS=$as_save_IFS
12372   if test -z "$ac_cv_path_SED"; then
12373     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12374   fi
12375 else
12376   ac_cv_path_SED=$SED
12377 fi
12378 
12379 fi
12380 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12381 $as_echo "$ac_cv_path_SED" >&6; }
12382  SED="$ac_cv_path_SED"
12383   rm -f conftest.sed
12384 
12385   else
12386     # The variable is set, but is it from the command line or the environment?
12387 
12388     # Try to remove the string !SED! from our list.
12389     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
12390     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12391       # If it failed, the variable was not from the command line. Ignore it,
12392       # but warn the user (except for BASH, which is always set by the calling BASH).
12393       if test "xSED" != xBASH; then
12394         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
12395 $as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
12396       fi
12397       # Try to locate tool using the code snippet
12398       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12399 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12400 if ${ac_cv_path_SED+:} false; then :
12401   $as_echo_n "(cached) " >&6
12402 else
12403             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12404      for ac_i in 1 2 3 4 5 6 7; do
12405        ac_script="$ac_script$as_nl$ac_script"
12406      done
12407      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12408      { ac_script=; unset ac_script;}
12409      if test -z "$SED"; then
12410   ac_path_SED_found=false
12411   # Loop through the user's path and test for each of PROGNAME-LIST
12412   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12413 for as_dir in $PATH
12414 do
12415   IFS=$as_save_IFS
12416   test -z "$as_dir" && as_dir=.
12417     for ac_prog in sed gsed; do
12418     for ac_exec_ext in '' $ac_executable_extensions; do
12419       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12420       as_fn_executable_p "$ac_path_SED" || continue
12421 # Check for GNU ac_path_SED and select it if it is found.
12422   # Check for GNU $ac_path_SED
12423 case `"$ac_path_SED" --version 2>&1` in
12424 *GNU*)
12425   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12426 *)
12427   ac_count=0
12428   $as_echo_n 0123456789 >"conftest.in"
12429   while :
12430   do
12431     cat "conftest.in" "conftest.in" >"conftest.tmp"
12432     mv "conftest.tmp" "conftest.in"
12433     cp "conftest.in" "conftest.nl"
12434     $as_echo '' >> "conftest.nl"
12435     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12436     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12437     as_fn_arith $ac_count + 1 && ac_count=$as_val
12438     if test $ac_count -gt ${ac_path_SED_max-0}; then
12439       # Best one so far, save it but keep looking for a better one
12440       ac_cv_path_SED="$ac_path_SED"
12441       ac_path_SED_max=$ac_count
12442     fi
12443     # 10*(2^10) chars as input seems more than enough
12444     test $ac_count -gt 10 && break
12445   done
12446   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12447 esac
12448 
12449       $ac_path_SED_found && break 3
12450     done
12451   done
12452   done
12453 IFS=$as_save_IFS
12454   if test -z "$ac_cv_path_SED"; then
12455     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12456   fi
12457 else
12458   ac_cv_path_SED=$SED
12459 fi
12460 
12461 fi
12462 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12463 $as_echo "$ac_cv_path_SED" >&6; }
12464  SED="$ac_cv_path_SED"
12465   rm -f conftest.sed
12466 
12467     else
12468       # If it succeeded, then it was overridden by the user. We will use it
12469       # for the tool.
12470 
12471       # First remove it from the list of overridden variables, so we can test
12472       # for unknown variables in the end.
12473       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12474 
12475       # Check if the provided tool contains a complete path.
12476       tool_specified="$SED"
12477       tool_basename="${tool_specified##*/}"
12478       if test "x$tool_basename" = "x$tool_specified"; then
12479         # A command without a complete path is provided, search $PATH.
12480         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
12481 $as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
12482         # Extract the first word of "$tool_basename", so it can be a program name with args.
12483 set dummy $tool_basename; ac_word=$2
12484 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12485 $as_echo_n "checking for $ac_word... " >&6; }
12486 if ${ac_cv_path_SED+:} false; then :
12487   $as_echo_n "(cached) " >&6
12488 else
12489   case $SED in
12490   [\\/]* | ?:[\\/]*)
12491   ac_cv_path_SED="$SED" # Let the user override the test with a path.
12492   ;;
12493   *)
12494   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12495 for as_dir in $PATH
12496 do
12497   IFS=$as_save_IFS
12498   test -z "$as_dir" && as_dir=.
12499     for ac_exec_ext in '' $ac_executable_extensions; do
12500   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12501     ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
12502     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12503     break 2
12504   fi
12505 done
12506   done
12507 IFS=$as_save_IFS
12508 
12509   ;;
12510 esac
12511 fi
12512 SED=$ac_cv_path_SED
12513 if test -n "$SED"; then
12514   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
12515 $as_echo "$SED" >&6; }
12516 else
12517   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12518 $as_echo "no" >&6; }
12519 fi
12520 
12521 
12522         if test "x$SED" = x; then
12523           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12524         fi
12525       else
12526         # Otherwise we believe it is a complete path. Use it as it is.
12527         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
12528 $as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
12529         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
12530 $as_echo_n "checking for SED... " >&6; }
12531         if test ! -x "$tool_specified"; then
12532           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12533 $as_echo "not found" >&6; }
12534           as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
12535         fi
12536         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12537 $as_echo "$tool_specified" >&6; }
12538       fi
12539     fi
12540   fi
12541 
12542 
12543   if test "x$SED" = x; then
12544     as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
12545   fi
12546 
12547 
12548 
12549   # Always force rm.
12550   RM="$RM -f"
12551 
12552   # pwd behaves differently on various platforms and some don't support the -L flag.
12553   # Always use the bash builtin pwd to get uniform behavior.
12554   THEPWDCMD=pwd
12555 
12556   # These are not required on all platforms
12557 
12558 
12559   # Publish this variable in the help.
12560 
12561 
12562   if test "x$CYGPATH" = x; then
12563     # The variable is not set by user, try to locate tool using the code snippet
12564     for ac_prog in cygpath
12565 do
12566   # Extract the first word of "$ac_prog", so it can be a program name with args.
12567 set dummy $ac_prog; ac_word=$2
12568 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12569 $as_echo_n "checking for $ac_word... " >&6; }
12570 if ${ac_cv_path_CYGPATH+:} false; then :
12571   $as_echo_n "(cached) " >&6
12572 else
12573   case $CYGPATH in
12574   [\\/]* | ?:[\\/]*)
12575   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12576   ;;
12577   *)
12578   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12579 for as_dir in $PATH
12580 do
12581   IFS=$as_save_IFS
12582   test -z "$as_dir" && as_dir=.
12583     for ac_exec_ext in '' $ac_executable_extensions; do
12584   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12585     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12586     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12587     break 2
12588   fi
12589 done
12590   done
12591 IFS=$as_save_IFS
12592 
12593   ;;
12594 esac
12595 fi
12596 CYGPATH=$ac_cv_path_CYGPATH
12597 if test -n "$CYGPATH"; then
12598   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12599 $as_echo "$CYGPATH" >&6; }
12600 else
12601   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12602 $as_echo "no" >&6; }
12603 fi
12604 
12605 
12606   test -n "$CYGPATH" && break
12607 done
12608 
12609   else
12610     # The variable is set, but is it from the command line or the environment?
12611 
12612     # Try to remove the string !CYGPATH! from our list.
12613     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
12614     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12615       # If it failed, the variable was not from the command line. Ignore it,
12616       # but warn the user (except for BASH, which is always set by the calling BASH).
12617       if test "xCYGPATH" != xBASH; then
12618         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
12619 $as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
12620       fi
12621       # Try to locate tool using the code snippet
12622       for ac_prog in cygpath
12623 do
12624   # Extract the first word of "$ac_prog", so it can be a program name with args.
12625 set dummy $ac_prog; ac_word=$2
12626 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12627 $as_echo_n "checking for $ac_word... " >&6; }
12628 if ${ac_cv_path_CYGPATH+:} false; then :
12629   $as_echo_n "(cached) " >&6
12630 else
12631   case $CYGPATH in
12632   [\\/]* | ?:[\\/]*)
12633   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12634   ;;
12635   *)
12636   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12637 for as_dir in $PATH
12638 do
12639   IFS=$as_save_IFS
12640   test -z "$as_dir" && as_dir=.
12641     for ac_exec_ext in '' $ac_executable_extensions; do
12642   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12643     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12644     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12645     break 2
12646   fi
12647 done
12648   done
12649 IFS=$as_save_IFS
12650 
12651   ;;
12652 esac
12653 fi
12654 CYGPATH=$ac_cv_path_CYGPATH
12655 if test -n "$CYGPATH"; then
12656   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12657 $as_echo "$CYGPATH" >&6; }
12658 else
12659   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12660 $as_echo "no" >&6; }
12661 fi
12662 
12663 
12664   test -n "$CYGPATH" && break
12665 done
12666 
12667     else
12668       # If it succeeded, then it was overridden by the user. We will use it
12669       # for the tool.
12670 
12671       # First remove it from the list of overridden variables, so we can test
12672       # for unknown variables in the end.
12673       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12674 
12675       # Check if the provided tool contains a complete path.
12676       tool_specified="$CYGPATH"
12677       tool_basename="${tool_specified##*/}"
12678       if test "x$tool_basename" = "x$tool_specified"; then
12679         # A command without a complete path is provided, search $PATH.
12680         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
12681 $as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
12682         # Extract the first word of "$tool_basename", so it can be a program name with args.
12683 set dummy $tool_basename; ac_word=$2
12684 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12685 $as_echo_n "checking for $ac_word... " >&6; }
12686 if ${ac_cv_path_CYGPATH+:} false; then :
12687   $as_echo_n "(cached) " >&6
12688 else
12689   case $CYGPATH in
12690   [\\/]* | ?:[\\/]*)
12691   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12692   ;;
12693   *)
12694   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12695 for as_dir in $PATH
12696 do
12697   IFS=$as_save_IFS
12698   test -z "$as_dir" && as_dir=.
12699     for ac_exec_ext in '' $ac_executable_extensions; do
12700   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12701     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12702     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12703     break 2
12704   fi
12705 done
12706   done
12707 IFS=$as_save_IFS
12708 
12709   ;;
12710 esac
12711 fi
12712 CYGPATH=$ac_cv_path_CYGPATH
12713 if test -n "$CYGPATH"; then
12714   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12715 $as_echo "$CYGPATH" >&6; }
12716 else
12717   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12718 $as_echo "no" >&6; }
12719 fi
12720 
12721 
12722         if test "x$CYGPATH" = x; then
12723           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12724         fi
12725       else
12726         # Otherwise we believe it is a complete path. Use it as it is.
12727         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
12728 $as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
12729         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
12730 $as_echo_n "checking for CYGPATH... " >&6; }
12731         if test ! -x "$tool_specified"; then
12732           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12733 $as_echo "not found" >&6; }
12734           as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
12735         fi
12736         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12737 $as_echo "$tool_specified" >&6; }
12738       fi
12739     fi
12740   fi
12741 
12742 
12743 
12744 
12745   # Publish this variable in the help.
12746 
12747 
12748   if test "x$READLINK" = x; then
12749     # The variable is not set by user, try to locate tool using the code snippet
12750     for ac_prog in greadlink readlink
12751 do
12752   # Extract the first word of "$ac_prog", so it can be a program name with args.
12753 set dummy $ac_prog; ac_word=$2
12754 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12755 $as_echo_n "checking for $ac_word... " >&6; }
12756 if ${ac_cv_path_READLINK+:} false; then :
12757   $as_echo_n "(cached) " >&6
12758 else
12759   case $READLINK in
12760   [\\/]* | ?:[\\/]*)
12761   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12762   ;;
12763   *)
12764   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12765 for as_dir in $PATH
12766 do
12767   IFS=$as_save_IFS
12768   test -z "$as_dir" && as_dir=.
12769     for ac_exec_ext in '' $ac_executable_extensions; do
12770   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12771     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12772     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12773     break 2
12774   fi
12775 done
12776   done
12777 IFS=$as_save_IFS
12778 
12779   ;;
12780 esac
12781 fi
12782 READLINK=$ac_cv_path_READLINK
12783 if test -n "$READLINK"; then
12784   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12785 $as_echo "$READLINK" >&6; }
12786 else
12787   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12788 $as_echo "no" >&6; }
12789 fi
12790 
12791 
12792   test -n "$READLINK" && break
12793 done
12794 
12795   else
12796     # The variable is set, but is it from the command line or the environment?
12797 
12798     # Try to remove the string !READLINK! from our list.
12799     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
12800     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12801       # If it failed, the variable was not from the command line. Ignore it,
12802       # but warn the user (except for BASH, which is always set by the calling BASH).
12803       if test "xREADLINK" != xBASH; then
12804         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
12805 $as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
12806       fi
12807       # Try to locate tool using the code snippet
12808       for ac_prog in greadlink readlink
12809 do
12810   # Extract the first word of "$ac_prog", so it can be a program name with args.
12811 set dummy $ac_prog; ac_word=$2
12812 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12813 $as_echo_n "checking for $ac_word... " >&6; }
12814 if ${ac_cv_path_READLINK+:} false; then :
12815   $as_echo_n "(cached) " >&6
12816 else
12817   case $READLINK in
12818   [\\/]* | ?:[\\/]*)
12819   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12820   ;;
12821   *)
12822   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12823 for as_dir in $PATH
12824 do
12825   IFS=$as_save_IFS
12826   test -z "$as_dir" && as_dir=.
12827     for ac_exec_ext in '' $ac_executable_extensions; do
12828   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12829     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12830     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12831     break 2
12832   fi
12833 done
12834   done
12835 IFS=$as_save_IFS
12836 
12837   ;;
12838 esac
12839 fi
12840 READLINK=$ac_cv_path_READLINK
12841 if test -n "$READLINK"; then
12842   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12843 $as_echo "$READLINK" >&6; }
12844 else
12845   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12846 $as_echo "no" >&6; }
12847 fi
12848 
12849 
12850   test -n "$READLINK" && break
12851 done
12852 
12853     else
12854       # If it succeeded, then it was overridden by the user. We will use it
12855       # for the tool.
12856 
12857       # First remove it from the list of overridden variables, so we can test
12858       # for unknown variables in the end.
12859       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12860 
12861       # Check if the provided tool contains a complete path.
12862       tool_specified="$READLINK"
12863       tool_basename="${tool_specified##*/}"
12864       if test "x$tool_basename" = "x$tool_specified"; then
12865         # A command without a complete path is provided, search $PATH.
12866         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
12867 $as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
12868         # Extract the first word of "$tool_basename", so it can be a program name with args.
12869 set dummy $tool_basename; ac_word=$2
12870 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12871 $as_echo_n "checking for $ac_word... " >&6; }
12872 if ${ac_cv_path_READLINK+:} false; then :
12873   $as_echo_n "(cached) " >&6
12874 else
12875   case $READLINK in
12876   [\\/]* | ?:[\\/]*)
12877   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12878   ;;
12879   *)
12880   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12881 for as_dir in $PATH
12882 do
12883   IFS=$as_save_IFS
12884   test -z "$as_dir" && as_dir=.
12885     for ac_exec_ext in '' $ac_executable_extensions; do
12886   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12887     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12888     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12889     break 2
12890   fi
12891 done
12892   done
12893 IFS=$as_save_IFS
12894 
12895   ;;
12896 esac
12897 fi
12898 READLINK=$ac_cv_path_READLINK
12899 if test -n "$READLINK"; then
12900   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12901 $as_echo "$READLINK" >&6; }
12902 else
12903   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12904 $as_echo "no" >&6; }
12905 fi
12906 
12907 
12908         if test "x$READLINK" = x; then
12909           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12910         fi
12911       else
12912         # Otherwise we believe it is a complete path. Use it as it is.
12913         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
12914 $as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
12915         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
12916 $as_echo_n "checking for READLINK... " >&6; }
12917         if test ! -x "$tool_specified"; then
12918           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12919 $as_echo "not found" >&6; }
12920           as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
12921         fi
12922         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12923 $as_echo "$tool_specified" >&6; }
12924       fi
12925     fi
12926   fi
12927 
12928 
12929 
12930 
12931   # Publish this variable in the help.
12932 
12933 
12934   if test "x$DF" = x; then
12935     # The variable is not set by user, try to locate tool using the code snippet
12936     for ac_prog in df
12937 do
12938   # Extract the first word of "$ac_prog", so it can be a program name with args.
12939 set dummy $ac_prog; ac_word=$2
12940 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12941 $as_echo_n "checking for $ac_word... " >&6; }
12942 if ${ac_cv_path_DF+:} false; then :
12943   $as_echo_n "(cached) " >&6
12944 else
12945   case $DF in
12946   [\\/]* | ?:[\\/]*)
12947   ac_cv_path_DF="$DF" # Let the user override the test with a path.
12948   ;;
12949   *)
12950   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12951 for as_dir in $PATH
12952 do
12953   IFS=$as_save_IFS
12954   test -z "$as_dir" && as_dir=.
12955     for ac_exec_ext in '' $ac_executable_extensions; do
12956   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12957     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12958     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12959     break 2
12960   fi
12961 done
12962   done
12963 IFS=$as_save_IFS
12964 
12965   ;;
12966 esac
12967 fi
12968 DF=$ac_cv_path_DF
12969 if test -n "$DF"; then
12970   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12971 $as_echo "$DF" >&6; }
12972 else
12973   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12974 $as_echo "no" >&6; }
12975 fi
12976 
12977 
12978   test -n "$DF" && break
12979 done
12980 
12981   else
12982     # The variable is set, but is it from the command line or the environment?
12983 
12984     # Try to remove the string !DF! from our list.
12985     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
12986     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12987       # If it failed, the variable was not from the command line. Ignore it,
12988       # but warn the user (except for BASH, which is always set by the calling BASH).
12989       if test "xDF" != xBASH; then
12990         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
12991 $as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
12992       fi
12993       # Try to locate tool using the code snippet
12994       for ac_prog in df
12995 do
12996   # Extract the first word of "$ac_prog", so it can be a program name with args.
12997 set dummy $ac_prog; ac_word=$2
12998 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12999 $as_echo_n "checking for $ac_word... " >&6; }
13000 if ${ac_cv_path_DF+:} false; then :
13001   $as_echo_n "(cached) " >&6
13002 else
13003   case $DF in
13004   [\\/]* | ?:[\\/]*)
13005   ac_cv_path_DF="$DF" # Let the user override the test with a path.
13006   ;;
13007   *)
13008   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13009 for as_dir in $PATH
13010 do
13011   IFS=$as_save_IFS
13012   test -z "$as_dir" && as_dir=.
13013     for ac_exec_ext in '' $ac_executable_extensions; do
13014   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13015     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
13016     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13017     break 2
13018   fi
13019 done
13020   done
13021 IFS=$as_save_IFS
13022 
13023   ;;
13024 esac
13025 fi
13026 DF=$ac_cv_path_DF
13027 if test -n "$DF"; then
13028   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
13029 $as_echo "$DF" >&6; }
13030 else
13031   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13032 $as_echo "no" >&6; }
13033 fi
13034 
13035 
13036   test -n "$DF" && break
13037 done
13038 
13039     else
13040       # If it succeeded, then it was overridden by the user. We will use it
13041       # for the tool.
13042 
13043       # First remove it from the list of overridden variables, so we can test
13044       # for unknown variables in the end.
13045       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13046 
13047       # Check if the provided tool contains a complete path.
13048       tool_specified="$DF"
13049       tool_basename="${tool_specified##*/}"
13050       if test "x$tool_basename" = "x$tool_specified"; then
13051         # A command without a complete path is provided, search $PATH.
13052         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
13053 $as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
13054         # Extract the first word of "$tool_basename", so it can be a program name with args.
13055 set dummy $tool_basename; ac_word=$2
13056 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13057 $as_echo_n "checking for $ac_word... " >&6; }
13058 if ${ac_cv_path_DF+:} false; then :
13059   $as_echo_n "(cached) " >&6
13060 else
13061   case $DF in
13062   [\\/]* | ?:[\\/]*)
13063   ac_cv_path_DF="$DF" # Let the user override the test with a path.
13064   ;;
13065   *)
13066   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13067 for as_dir in $PATH
13068 do
13069   IFS=$as_save_IFS
13070   test -z "$as_dir" && as_dir=.
13071     for ac_exec_ext in '' $ac_executable_extensions; do
13072   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13073     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
13074     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13075     break 2
13076   fi
13077 done
13078   done
13079 IFS=$as_save_IFS
13080 
13081   ;;
13082 esac
13083 fi
13084 DF=$ac_cv_path_DF
13085 if test -n "$DF"; then
13086   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
13087 $as_echo "$DF" >&6; }
13088 else
13089   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13090 $as_echo "no" >&6; }
13091 fi
13092 
13093 
13094         if test "x$DF" = x; then
13095           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13096         fi
13097       else
13098         # Otherwise we believe it is a complete path. Use it as it is.
13099         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
13100 $as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
13101         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
13102 $as_echo_n "checking for DF... " >&6; }
13103         if test ! -x "$tool_specified"; then
13104           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13105 $as_echo "not found" >&6; }
13106           as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
13107         fi
13108         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13109 $as_echo "$tool_specified" >&6; }
13110       fi
13111     fi
13112   fi
13113 
13114 
13115 
13116 
13117   # Publish this variable in the help.
13118 
13119 
13120   if test "x$SETFILE" = x; then
13121     # The variable is not set by user, try to locate tool using the code snippet
13122     for ac_prog in SetFile
13123 do
13124   # Extract the first word of "$ac_prog", so it can be a program name with args.
13125 set dummy $ac_prog; ac_word=$2
13126 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13127 $as_echo_n "checking for $ac_word... " >&6; }
13128 if ${ac_cv_path_SETFILE+:} false; then :
13129   $as_echo_n "(cached) " >&6
13130 else
13131   case $SETFILE in
13132   [\\/]* | ?:[\\/]*)
13133   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13134   ;;
13135   *)
13136   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13137 for as_dir in $PATH
13138 do
13139   IFS=$as_save_IFS
13140   test -z "$as_dir" && as_dir=.
13141     for ac_exec_ext in '' $ac_executable_extensions; do
13142   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13143     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13144     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13145     break 2
13146   fi
13147 done
13148   done
13149 IFS=$as_save_IFS
13150 
13151   ;;
13152 esac
13153 fi
13154 SETFILE=$ac_cv_path_SETFILE
13155 if test -n "$SETFILE"; then
13156   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13157 $as_echo "$SETFILE" >&6; }
13158 else
13159   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13160 $as_echo "no" >&6; }
13161 fi
13162 
13163 
13164   test -n "$SETFILE" && break
13165 done
13166 
13167   else
13168     # The variable is set, but is it from the command line or the environment?
13169 
13170     # Try to remove the string !SETFILE! from our list.
13171     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
13172     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13173       # If it failed, the variable was not from the command line. Ignore it,
13174       # but warn the user (except for BASH, which is always set by the calling BASH).
13175       if test "xSETFILE" != xBASH; then
13176         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
13177 $as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
13178       fi
13179       # Try to locate tool using the code snippet
13180       for ac_prog in SetFile
13181 do
13182   # Extract the first word of "$ac_prog", so it can be a program name with args.
13183 set dummy $ac_prog; ac_word=$2
13184 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13185 $as_echo_n "checking for $ac_word... " >&6; }
13186 if ${ac_cv_path_SETFILE+:} false; then :
13187   $as_echo_n "(cached) " >&6
13188 else
13189   case $SETFILE in
13190   [\\/]* | ?:[\\/]*)
13191   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13192   ;;
13193   *)
13194   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13195 for as_dir in $PATH
13196 do
13197   IFS=$as_save_IFS
13198   test -z "$as_dir" && as_dir=.
13199     for ac_exec_ext in '' $ac_executable_extensions; do
13200   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13201     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13202     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13203     break 2
13204   fi
13205 done
13206   done
13207 IFS=$as_save_IFS
13208 
13209   ;;
13210 esac
13211 fi
13212 SETFILE=$ac_cv_path_SETFILE
13213 if test -n "$SETFILE"; then
13214   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13215 $as_echo "$SETFILE" >&6; }
13216 else
13217   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13218 $as_echo "no" >&6; }
13219 fi
13220 
13221 
13222   test -n "$SETFILE" && break
13223 done
13224 
13225     else
13226       # If it succeeded, then it was overridden by the user. We will use it
13227       # for the tool.
13228 
13229       # First remove it from the list of overridden variables, so we can test
13230       # for unknown variables in the end.
13231       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13232 
13233       # Check if the provided tool contains a complete path.
13234       tool_specified="$SETFILE"
13235       tool_basename="${tool_specified##*/}"
13236       if test "x$tool_basename" = "x$tool_specified"; then
13237         # A command without a complete path is provided, search $PATH.
13238         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
13239 $as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
13240         # Extract the first word of "$tool_basename", so it can be a program name with args.
13241 set dummy $tool_basename; ac_word=$2
13242 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13243 $as_echo_n "checking for $ac_word... " >&6; }
13244 if ${ac_cv_path_SETFILE+:} false; then :
13245   $as_echo_n "(cached) " >&6
13246 else
13247   case $SETFILE in
13248   [\\/]* | ?:[\\/]*)
13249   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13250   ;;
13251   *)
13252   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13253 for as_dir in $PATH
13254 do
13255   IFS=$as_save_IFS
13256   test -z "$as_dir" && as_dir=.
13257     for ac_exec_ext in '' $ac_executable_extensions; do
13258   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13259     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13260     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13261     break 2
13262   fi
13263 done
13264   done
13265 IFS=$as_save_IFS
13266 
13267   ;;
13268 esac
13269 fi
13270 SETFILE=$ac_cv_path_SETFILE
13271 if test -n "$SETFILE"; then
13272   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13273 $as_echo "$SETFILE" >&6; }
13274 else
13275   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13276 $as_echo "no" >&6; }
13277 fi
13278 
13279 
13280         if test "x$SETFILE" = x; then
13281           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13282         fi
13283       else
13284         # Otherwise we believe it is a complete path. Use it as it is.
13285         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
13286 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
13287         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
13288 $as_echo_n "checking for SETFILE... " >&6; }
13289         if test ! -x "$tool_specified"; then
13290           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13291 $as_echo "not found" >&6; }
13292           as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
13293         fi
13294         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13295 $as_echo "$tool_specified" >&6; }
13296       fi
13297     fi
13298   fi
13299 
13300 
13301 
13302 
13303 # Now we can determine OpenJDK build and target platforms. This is required to
13304 # have early on.
13305 # Make sure we can run config.sub.
13306 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
13307   as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
13308 
13309 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
13310 $as_echo_n "checking build system type... " >&6; }
13311 if ${ac_cv_build+:} false; then :
13312   $as_echo_n "(cached) " >&6
13313 else
13314   ac_build_alias=$build_alias
13315 test "x$ac_build_alias" = x &&
13316   ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
13317 test "x$ac_build_alias" = x &&
13318   as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
13319 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
13320   as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
13321 
13322 fi
13323 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
13324 $as_echo "$ac_cv_build" >&6; }
13325 case $ac_cv_build in
13326 *-*-*) ;;
13327 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
13328 esac
13329 build=$ac_cv_build
13330 ac_save_IFS=$IFS; IFS='-'
13331 set x $ac_cv_build
13332 shift
13333 build_cpu=$1
13334 build_vendor=$2
13335 shift; shift
13336 # Remember, the first character of IFS is used to create $*,
13337 # except with old shells:
13338 build_os=$*
13339 IFS=$ac_save_IFS
13340 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
13341 
13342 
13343 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
13344 $as_echo_n "checking host system type... " >&6; }
13345 if ${ac_cv_host+:} false; then :
13346   $as_echo_n "(cached) " >&6
13347 else
13348   if test "x$host_alias" = x; then
13349   ac_cv_host=$ac_cv_build
13350 else
13351   ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
13352     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
13353 fi
13354 
13355 fi
13356 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
13357 $as_echo "$ac_cv_host" >&6; }
13358 case $ac_cv_host in
13359 *-*-*) ;;
13360 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
13361 esac
13362 host=$ac_cv_host
13363 ac_save_IFS=$IFS; IFS='-'
13364 set x $ac_cv_host
13365 shift
13366 host_cpu=$1
13367 host_vendor=$2
13368 shift; shift
13369 # Remember, the first character of IFS is used to create $*,
13370 # except with old shells:
13371 host_os=$*
13372 IFS=$ac_save_IFS
13373 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
13374 
13375 
13376 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
13377 $as_echo_n "checking target system type... " >&6; }
13378 if ${ac_cv_target+:} false; then :
13379   $as_echo_n "(cached) " >&6
13380 else
13381   if test "x$target_alias" = x; then
13382   ac_cv_target=$ac_cv_host
13383 else
13384   ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
13385     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
13386 fi
13387 
13388 fi
13389 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
13390 $as_echo "$ac_cv_target" >&6; }
13391 case $ac_cv_target in
13392 *-*-*) ;;
13393 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
13394 esac
13395 target=$ac_cv_target
13396 ac_save_IFS=$IFS; IFS='-'
13397 set x $ac_cv_target
13398 shift
13399 target_cpu=$1
13400 target_vendor=$2
13401 shift; shift
13402 # Remember, the first character of IFS is used to create $*,
13403 # except with old shells:
13404 target_os=$*
13405 IFS=$ac_save_IFS
13406 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
13407 
13408 
13409 # The aliases save the names the user supplied, while $host etc.
13410 # will get canonicalized.
13411 test -n "$target_alias" &&
13412   test "$program_prefix$program_suffix$program_transform_name" = \
13413     NONENONEs,x,x, &&
13414   program_prefix=${target_alias}-
13415 
13416   # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
13417   # is confusing; it assumes you are cross-compiling a cross-compiler (!)  and "target" is thus the target of the
13418   # product you're building. The target of this build is called "host". Since this is confusing to most people, we
13419   # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
13420   # to use the configure naming style.
13421 
13422 
13423 
13424 
13425 
13426   # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
13427   # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
13428   # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
13429   # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
13430   OPENJDK_TARGET_AUTOCONF_NAME="$host"
13431   OPENJDK_BUILD_AUTOCONF_NAME="$build"
13432 
13433 
13434 
13435   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13436 
13437   case "$build_os" in
13438     *linux*)
13439       VAR_OS=linux
13440       VAR_OS_API=posix
13441       VAR_OS_ENV=linux
13442       ;;
13443     *solaris*)
13444       VAR_OS=solaris
13445       VAR_OS_API=posix
13446       VAR_OS_ENV=solaris
13447       ;;
13448     *darwin*)
13449       VAR_OS=macosx
13450       VAR_OS_API=posix
13451       VAR_OS_ENV=macosx
13452       ;;
13453     *bsd*)
13454       VAR_OS=bsd
13455       VAR_OS_API=posix
13456       VAR_OS_ENV=bsd
13457       ;;
13458     *cygwin*)
13459       VAR_OS=windows
13460       VAR_OS_API=winapi
13461       VAR_OS_ENV=windows.cygwin
13462       ;;
13463     *mingw*)
13464       VAR_OS=windows
13465       VAR_OS_API=winapi
13466       VAR_OS_ENV=windows.msys
13467       ;;
13468     *aix*)
13469       VAR_OS=aix
13470       VAR_OS_API=posix
13471       VAR_OS_ENV=aix
13472       ;;
13473     *)
13474       as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
13475       ;;
13476   esac
13477 
13478 
13479   # First argument is the cpu name from the trip/quad
13480   case "$build_cpu" in
13481     x86_64)
13482       VAR_CPU=x86_64
13483       VAR_CPU_ARCH=x86
13484       VAR_CPU_BITS=64
13485       VAR_CPU_ENDIAN=little
13486       ;;
13487     i?86)
13488       VAR_CPU=x86
13489       VAR_CPU_ARCH=x86
13490       VAR_CPU_BITS=32
13491       VAR_CPU_ENDIAN=little
13492       ;;
13493     arm*)
13494       VAR_CPU=arm
13495       VAR_CPU_ARCH=arm
13496       VAR_CPU_BITS=32
13497       VAR_CPU_ENDIAN=little
13498       ;;
13499     powerpc)
13500       VAR_CPU=ppc
13501       VAR_CPU_ARCH=ppc
13502       VAR_CPU_BITS=32
13503       VAR_CPU_ENDIAN=big
13504       ;;
13505     powerpc64)
13506       VAR_CPU=ppc64
13507       VAR_CPU_ARCH=ppc
13508       VAR_CPU_BITS=64
13509       VAR_CPU_ENDIAN=big
13510       ;;
13511     s390)
13512       VAR_CPU=s390
13513       VAR_CPU_ARCH=s390
13514       VAR_CPU_BITS=32
13515       VAR_CPU_ENDIAN=big
13516       ;;
13517     s390x)
13518       VAR_CPU=s390x
13519       VAR_CPU_ARCH=s390
13520       VAR_CPU_BITS=64
13521       VAR_CPU_ENDIAN=big
13522       ;;
13523     sparc)
13524       VAR_CPU=sparc
13525       VAR_CPU_ARCH=sparc
13526       VAR_CPU_BITS=32
13527       VAR_CPU_ENDIAN=big
13528       ;;
13529     sparcv9)
13530       VAR_CPU=sparcv9
13531       VAR_CPU_ARCH=sparc
13532       VAR_CPU_BITS=64
13533       VAR_CPU_ENDIAN=big
13534       ;;
13535     *)
13536       as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
13537       ;;
13538   esac
13539 
13540   # ..and setup our own variables. (Do this explicitely to facilitate searching)
13541   OPENJDK_BUILD_OS="$VAR_OS"
13542   OPENJDK_BUILD_OS_API="$VAR_OS_API"
13543   OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
13544   OPENJDK_BUILD_CPU="$VAR_CPU"
13545   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
13546   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
13547   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13548 
13549 
13550 
13551 
13552 
13553 
13554 
13555   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
13556 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
13557   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
13558 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
13559 
13560   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13561 
13562   case "$host_os" in
13563     *linux*)
13564       VAR_OS=linux
13565       VAR_OS_API=posix
13566       VAR_OS_ENV=linux
13567       ;;
13568     *solaris*)
13569       VAR_OS=solaris
13570       VAR_OS_API=posix
13571       VAR_OS_ENV=solaris
13572       ;;
13573     *darwin*)
13574       VAR_OS=macosx
13575       VAR_OS_API=posix
13576       VAR_OS_ENV=macosx
13577       ;;
13578     *bsd*)
13579       VAR_OS=bsd
13580       VAR_OS_API=posix
13581       VAR_OS_ENV=bsd
13582       ;;
13583     *cygwin*)
13584       VAR_OS=windows
13585       VAR_OS_API=winapi
13586       VAR_OS_ENV=windows.cygwin
13587       ;;
13588     *mingw*)
13589       VAR_OS=windows
13590       VAR_OS_API=winapi
13591       VAR_OS_ENV=windows.msys
13592       ;;
13593     *aix*)
13594       VAR_OS=aix
13595       VAR_OS_API=posix
13596       VAR_OS_ENV=aix
13597       ;;
13598     *)
13599       as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
13600       ;;
13601   esac
13602 
13603 
13604   # First argument is the cpu name from the trip/quad
13605   case "$host_cpu" in
13606     x86_64)
13607       VAR_CPU=x86_64
13608       VAR_CPU_ARCH=x86
13609       VAR_CPU_BITS=64
13610       VAR_CPU_ENDIAN=little
13611       ;;
13612     i?86)
13613       VAR_CPU=x86
13614       VAR_CPU_ARCH=x86
13615       VAR_CPU_BITS=32
13616       VAR_CPU_ENDIAN=little
13617       ;;
13618     arm*)
13619       VAR_CPU=arm
13620       VAR_CPU_ARCH=arm
13621       VAR_CPU_BITS=32
13622       VAR_CPU_ENDIAN=little
13623       ;;
13624     powerpc)
13625       VAR_CPU=ppc
13626       VAR_CPU_ARCH=ppc
13627       VAR_CPU_BITS=32
13628       VAR_CPU_ENDIAN=big
13629       ;;
13630     powerpc64)
13631       VAR_CPU=ppc64
13632       VAR_CPU_ARCH=ppc
13633       VAR_CPU_BITS=64
13634       VAR_CPU_ENDIAN=big
13635       ;;
13636     s390)
13637       VAR_CPU=s390
13638       VAR_CPU_ARCH=s390
13639       VAR_CPU_BITS=32
13640       VAR_CPU_ENDIAN=big
13641       ;;
13642     s390x)
13643       VAR_CPU=s390x
13644       VAR_CPU_ARCH=s390
13645       VAR_CPU_BITS=64
13646       VAR_CPU_ENDIAN=big
13647       ;;
13648     sparc)
13649       VAR_CPU=sparc
13650       VAR_CPU_ARCH=sparc
13651       VAR_CPU_BITS=32
13652       VAR_CPU_ENDIAN=big
13653       ;;
13654     sparcv9)
13655       VAR_CPU=sparcv9
13656       VAR_CPU_ARCH=sparc
13657       VAR_CPU_BITS=64
13658       VAR_CPU_ENDIAN=big
13659       ;;
13660     *)
13661       as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
13662       ;;
13663   esac
13664 
13665   # ... and setup our own variables. (Do this explicitely to facilitate searching)
13666   OPENJDK_TARGET_OS="$VAR_OS"
13667   OPENJDK_TARGET_OS_API="$VAR_OS_API"
13668   OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
13669   OPENJDK_TARGET_CPU="$VAR_CPU"
13670   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
13671   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
13672   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13673 
13674 
13675 
13676 
13677 
13678 
13679 
13680   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
13681 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
13682   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
13683 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
13684 
13685 
13686 
13687 # Check whether --with-target-bits was given.
13688 if test "${with_target_bits+set}" = set; then :
13689   withval=$with_target_bits;
13690 fi
13691 
13692 
13693   # We have three types of compiles:
13694   # native  == normal compilation, target system == build system
13695   # cross   == traditional cross compilation, target system != build system; special toolchain needed
13696   # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
13697   #
13698   if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
13699     # We're doing a proper cross-compilation
13700     COMPILE_TYPE="cross"
13701   else
13702     COMPILE_TYPE="native"
13703   fi
13704 
13705   if test "x$with_target_bits" != x; then
13706     if test "x$COMPILE_TYPE" = "xcross"; then
13707       as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
13708     fi
13709 
13710     if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13711       # A reduced build is requested
13712       COMPILE_TYPE="reduced"
13713       OPENJDK_TARGET_CPU_BITS=32
13714       if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
13715         OPENJDK_TARGET_CPU=x86
13716       elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
13717         OPENJDK_TARGET_CPU=sparc
13718       else
13719         as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
13720       fi
13721     elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
13722       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
13723     elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
13724       { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
13725 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
13726     else
13727       as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
13728     fi
13729   fi
13730 
13731 
13732   { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
13733 $as_echo_n "checking compilation type... " >&6; }
13734   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
13735 $as_echo "$COMPILE_TYPE" >&6; }
13736 
13737 
13738   if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
13739     REQUIRED_OS_NAME=SunOS
13740     REQUIRED_OS_VERSION=5.10
13741   fi
13742   if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
13743     REQUIRED_OS_NAME=Linux
13744     REQUIRED_OS_VERSION=2.6
13745   fi
13746   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
13747     REQUIRED_OS_NAME=Windows
13748     if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
13749       REQUIRED_OS_VERSION=5.2
13750     else
13751       REQUIRED_OS_VERSION=5.1
13752     fi
13753   fi
13754   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
13755     REQUIRED_OS_NAME=Darwin
13756     REQUIRED_OS_VERSION=11.2
13757   fi
13758 
13759 
13760 
13761 
13762 
13763   # Also store the legacy naming of the cpu.
13764   # Ie i586 and amd64 instead of x86 and x86_64
13765   OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
13766   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13767     OPENJDK_TARGET_CPU_LEGACY="i586"
13768   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13769     # On all platforms except MacOSX replace x86_64 with amd64.
13770     OPENJDK_TARGET_CPU_LEGACY="amd64"
13771   fi
13772 
13773 
13774   # And the second legacy naming of the cpu.
13775   # Ie i386 and amd64 instead of x86 and x86_64.
13776   OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
13777   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13778     OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
13779   elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13780     OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
13781   fi
13782 
13783 
13784   # This is the name of the cpu (but using i386 and amd64 instead of
13785   # x86 and x86_64, respectively), preceeded by a /, to be used when
13786   # locating libraries. On macosx, it's empty, though.
13787   OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
13788   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13789     OPENJDK_TARGET_CPU_LIBDIR=""
13790   fi
13791 
13792 
13793   # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
13794   # /amd64 or /sparcv9. This string is appended to some library paths, like this:
13795   # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
13796   OPENJDK_TARGET_CPU_ISADIR=""
13797   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13798     if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13799       OPENJDK_TARGET_CPU_ISADIR="/amd64"
13800     elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
13801       OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
13802     fi
13803   fi
13804 
13805 
13806   # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
13807   OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
13808   if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
13809     # On linux only, we replace x86 with i386.
13810     OPENJDK_TARGET_CPU_OSARCH="i386"
13811   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13812     # On all platforms except macosx, we replace x86_64 with amd64.
13813     OPENJDK_TARGET_CPU_OSARCH="amd64"
13814   fi
13815 
13816 
13817   OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
13818   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13819     OPENJDK_TARGET_CPU_JLI="i386"
13820   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13821     # On all platforms except macosx, we replace x86_64 with amd64.
13822     OPENJDK_TARGET_CPU_JLI="amd64"
13823   fi
13824   # Now setup the -D flags for building libjli.
13825   OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
13826   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13827     if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
13828       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
13829     elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
13830       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
13831     fi
13832   fi
13833 
13834 
13835   # Setup OPENJDK_TARGET_OS_API_DIR, used in source paths.
13836   if test "x$OPENJDK_TARGET_OS_API" = xposix; then
13837     OPENJDK_TARGET_OS_API_DIR="solaris"
13838   fi
13839   if test "x$OPENJDK_TARGET_OS_API" = xwinapi; then
13840     OPENJDK_TARGET_OS_API_DIR="windows"
13841   fi
13842 
13843 
13844   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13845       OPENJDK_TARGET_OS_EXPORT_DIR=macosx
13846   else
13847       OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_API_DIR}
13848   fi
13849 
13850 
13851   if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13852     A_LP64="LP64:="
13853     # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
13854     # unpack200.exe
13855     if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
13856       ADD_LP64="-D_LP64=1"
13857     fi
13858   fi
13859   LP64=$A_LP64
13860 
13861 
13862   if test "x$COMPILE_TYPE" = "xcross"; then
13863     # FIXME: ... or should this include reduced builds..?
13864     DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
13865   else
13866     DEFINE_CROSS_COMPILE_ARCH=""
13867   fi
13868 
13869 
13870   # ZERO_ARCHDEF is used to enable architecture-specific code
13871   case "${OPENJDK_TARGET_CPU}" in
13872     ppc*)    ZERO_ARCHDEF=PPC   ;;
13873     s390*)   ZERO_ARCHDEF=S390  ;;
13874     sparc*)  ZERO_ARCHDEF=SPARC ;;
13875     x86_64*) ZERO_ARCHDEF=AMD64 ;;
13876     x86)     ZERO_ARCHDEF=IA32  ;;
13877     *)      ZERO_ARCHDEF=$(echo "${OPENJDK_TARGET_CPU_LEGACY_LIB}" | tr a-z A-Z)
13878   esac
13879 
13880 
13881 
13882 
13883 # Continue setting up basic stuff. Most remaining code require fundamental tools.
13884 
13885   # Save the current directory this script was started from
13886   CURDIR="$PWD"
13887 
13888   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
13889     PATH_SEP=";"
13890 
13891   SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
13892   if test $SRC_ROOT_LENGTH -gt 100; then
13893     as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
13894   fi
13895 
13896   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13897     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
13898 $as_echo_n "checking cygwin release... " >&6; }
13899     CYGWIN_VERSION=`$UNAME -r`
13900     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
13901 $as_echo "$CYGWIN_VERSION" >&6; }
13902     WINDOWS_ENV_VENDOR='cygwin'
13903     WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
13904 
13905     CYGWIN_VERSION_OK=`$ECHO $CYGWIN_VERSION | $GREP ^1.7.`
13906     if test "x$CYGWIN_VERSION_OK" = x; then
13907       { $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
13908 $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;}
13909       as_fn_error $? "Cannot continue" "$LINENO" 5
13910     fi
13911     if test "x$CYGPATH" = x; then
13912       as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
13913     fi
13914     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
13915 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
13916     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
13917     cygwin_winpath_root=`cd / ; cmd /c cd | grep ".*"`
13918     # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
13919     CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
13920     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
13921 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
13922     WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
13923     test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
13924     if test "x$test_cygdrive_prefix" = x; then
13925       as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
13926     fi
13927   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
13928     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
13929 $as_echo_n "checking msys release... " >&6; }
13930     MSYS_VERSION=`$UNAME -r`
13931     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
13932 $as_echo "$MSYS_VERSION" >&6; }
13933 
13934     WINDOWS_ENV_VENDOR='msys'
13935     WINDOWS_ENV_VERSION="$MSYS_VERSION"
13936 
13937     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
13938 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
13939     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
13940     MSYS_ROOT_PATH=`cd / ; cmd /c cd | grep ".*"`
13941 
13942   windows_path="$MSYS_ROOT_PATH"
13943   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13944     unix_path=`$CYGPATH -u "$windows_path"`
13945     MSYS_ROOT_PATH="$unix_path"
13946   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
13947     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
13948     MSYS_ROOT_PATH="$unix_path"
13949   fi
13950 
13951     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
13952 $as_echo "$MSYS_ROOT_PATH" >&6; }
13953     WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
13954   else
13955     as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
13956   fi
13957 
13958   # Test if windows or unix (cygwin/msys) find is first in path.
13959   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
13960 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
13961   FIND_BINARY_OUTPUT=`find --version 2>&1`
13962   if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
13963     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
13964 $as_echo "unix style" >&6; }
13965   elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
13966     { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
13967 $as_echo "Windows" >&6; }
13968     { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
13969 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
13970     { $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
13971 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
13972     as_fn_error $? "Cannot continue" "$LINENO" 5
13973   else
13974     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
13975 $as_echo "unknown" >&6; }
13976     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
13977 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
13978   fi
13979 
13980   else
13981     PATH_SEP=":"
13982   fi
13983 
13984 
13985   # We get the top-level directory from the supporting wrappers.
13986   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
13987 $as_echo_n "checking for top-level directory... " >&6; }
13988   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
13989 $as_echo "$TOPDIR" >&6; }
13990 
13991 
13992   # We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
13993 
13994   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
13995 
13996   # Input might be given as Windows format, start by converting to
13997   # unix format.
13998   path="$CURDIR"
13999   new_path=`$CYGPATH -u "$path"`
14000 
14001   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14002   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14003   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14004   # "foo.exe" is OK but "foo" is an error.
14005   #
14006   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14007   # It is also a way to make sure we got the proper file name for the real test later on.
14008   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14009   if test "x$test_shortpath" = x; then
14010     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14011 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14012     as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
14013   fi
14014 
14015   # Call helper function which possibly converts this using DOS-style short mode.
14016   # If so, the updated path is stored in $new_path.
14017 
14018   input_path="$new_path"
14019   # Check if we need to convert this using DOS-style short mode. If the path
14020   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14021   # take no chances and rewrite it.
14022   # Note: m4 eats our [], so we need to use [ and ] instead.
14023   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14024   if test "x$has_forbidden_chars" != x; then
14025     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14026     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14027     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14028     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14029       # Going to short mode and back again did indeed matter. Since short mode is
14030       # case insensitive, let's make it lowercase to improve readability.
14031       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14032       # Now convert it back to Unix-stile (cygpath)
14033       input_path=`$CYGPATH -u "$shortmode_path"`
14034       new_path="$input_path"
14035     fi
14036   fi
14037 
14038   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14039   if test "x$test_cygdrive_prefix" = x; then
14040     # As a simple fix, exclude /usr/bin since it's not a real path.
14041     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14042       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14043       # a path prefixed by /cygdrive for fixpath to work.
14044       new_path="$CYGWIN_ROOT_PATH$input_path"
14045     fi
14046   fi
14047 
14048 
14049   if test "x$path" != "x$new_path"; then
14050     CURDIR="$new_path"
14051     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14052 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14053   fi
14054 
14055   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14056 
14057   path="$CURDIR"
14058   has_colon=`$ECHO $path | $GREP ^.:`
14059   new_path="$path"
14060   if test "x$has_colon" = x; then
14061     # Not in mixed or Windows style, start by that.
14062     new_path=`cmd //c echo $path`
14063   fi
14064 
14065 
14066   input_path="$new_path"
14067   # Check if we need to convert this using DOS-style short mode. If the path
14068   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14069   # take no chances and rewrite it.
14070   # Note: m4 eats our [], so we need to use [ and ] instead.
14071   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14072   if test "x$has_forbidden_chars" != x; then
14073     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14074     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14075   fi
14076 
14077 
14078   windows_path="$new_path"
14079   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14080     unix_path=`$CYGPATH -u "$windows_path"`
14081     new_path="$unix_path"
14082   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14083     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14084     new_path="$unix_path"
14085   fi
14086 
14087   if test "x$path" != "x$new_path"; then
14088     CURDIR="$new_path"
14089     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14090 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14091   fi
14092 
14093   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14094   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14095 
14096   else
14097     # We're on a posix platform. Hooray! :)
14098     path="$CURDIR"
14099     has_space=`$ECHO "$path" | $GREP " "`
14100     if test "x$has_space" != x; then
14101       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14102 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14103       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14104     fi
14105 
14106     # Use eval to expand a potential ~
14107     eval path="$path"
14108     if test ! -f "$path" && test ! -d "$path"; then
14109       as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14110     fi
14111 
14112     CURDIR="`cd "$path"; $THEPWDCMD -L`"
14113   fi
14114 
14115 
14116   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14117 
14118   # Input might be given as Windows format, start by converting to
14119   # unix format.
14120   path="$TOPDIR"
14121   new_path=`$CYGPATH -u "$path"`
14122 
14123   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14124   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14125   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14126   # "foo.exe" is OK but "foo" is an error.
14127   #
14128   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14129   # It is also a way to make sure we got the proper file name for the real test later on.
14130   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14131   if test "x$test_shortpath" = x; then
14132     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14133 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14134     as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
14135   fi
14136 
14137   # Call helper function which possibly converts this using DOS-style short mode.
14138   # If so, the updated path is stored in $new_path.
14139 
14140   input_path="$new_path"
14141   # Check if we need to convert this using DOS-style short mode. If the path
14142   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14143   # take no chances and rewrite it.
14144   # Note: m4 eats our [], so we need to use [ and ] instead.
14145   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14146   if test "x$has_forbidden_chars" != x; then
14147     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14148     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14149     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14150     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14151       # Going to short mode and back again did indeed matter. Since short mode is
14152       # case insensitive, let's make it lowercase to improve readability.
14153       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14154       # Now convert it back to Unix-stile (cygpath)
14155       input_path=`$CYGPATH -u "$shortmode_path"`
14156       new_path="$input_path"
14157     fi
14158   fi
14159 
14160   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14161   if test "x$test_cygdrive_prefix" = x; then
14162     # As a simple fix, exclude /usr/bin since it's not a real path.
14163     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14164       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14165       # a path prefixed by /cygdrive for fixpath to work.
14166       new_path="$CYGWIN_ROOT_PATH$input_path"
14167     fi
14168   fi
14169 
14170 
14171   if test "x$path" != "x$new_path"; then
14172     TOPDIR="$new_path"
14173     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14174 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14175   fi
14176 
14177   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14178 
14179   path="$TOPDIR"
14180   has_colon=`$ECHO $path | $GREP ^.:`
14181   new_path="$path"
14182   if test "x$has_colon" = x; then
14183     # Not in mixed or Windows style, start by that.
14184     new_path=`cmd //c echo $path`
14185   fi
14186 
14187 
14188   input_path="$new_path"
14189   # Check if we need to convert this using DOS-style short mode. If the path
14190   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14191   # take no chances and rewrite it.
14192   # Note: m4 eats our [], so we need to use [ and ] instead.
14193   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14194   if test "x$has_forbidden_chars" != x; then
14195     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14196     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14197   fi
14198 
14199 
14200   windows_path="$new_path"
14201   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14202     unix_path=`$CYGPATH -u "$windows_path"`
14203     new_path="$unix_path"
14204   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14205     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14206     new_path="$unix_path"
14207   fi
14208 
14209   if test "x$path" != "x$new_path"; then
14210     TOPDIR="$new_path"
14211     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14212 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14213   fi
14214 
14215   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14216   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14217 
14218   else
14219     # We're on a posix platform. Hooray! :)
14220     path="$TOPDIR"
14221     has_space=`$ECHO "$path" | $GREP " "`
14222     if test "x$has_space" != x; then
14223       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14224 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14225       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14226     fi
14227 
14228     # Use eval to expand a potential ~
14229     eval path="$path"
14230     if test ! -f "$path" && test ! -d "$path"; then
14231       as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14232     fi
14233 
14234     TOPDIR="`cd "$path"; $THEPWDCMD -L`"
14235   fi
14236 
14237   # SRC_ROOT is a traditional alias for TOPDIR.
14238   SRC_ROOT=$TOPDIR
14239 
14240   # Locate the directory of this script.
14241   AUTOCONF_DIR=$TOPDIR/common/autoconf
14242 
14243   if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
14244     # Add extra search paths on solaris for utilities like ar and as etc...
14245     PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin"
14246   fi
14247 
14248   # You can force the sys-root if the sys-root encoded into the cross compiler tools
14249   # is not correct.
14250 
14251 # Check whether --with-sys-root was given.
14252 if test "${with_sys_root+set}" = set; then :
14253   withval=$with_sys_root;
14254 fi
14255 
14256 
14257   if test "x$with_sys_root" != x; then
14258     SYS_ROOT=$with_sys_root
14259   else
14260     SYS_ROOT=/
14261   fi
14262 
14263 
14264 
14265 # Check whether --with-tools-dir was given.
14266 if test "${with_tools_dir+set}" = set; then :
14267   withval=$with_tools_dir; TOOLS_DIR=$with_tools_dir
14268 
14269 fi
14270 
14271 
14272 
14273 # Check whether --with-devkit was given.
14274 if test "${with_devkit+set}" = set; then :
14275   withval=$with_devkit;
14276         if test "x$with_sys_root" != x; then
14277           as_fn_error $? "Cannot specify both --with-devkit and --with-sys-root at the same time" "$LINENO" 5
14278         fi
14279 
14280   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14281 
14282   # Input might be given as Windows format, start by converting to
14283   # unix format.
14284   path="$with_devkit"
14285   new_path=`$CYGPATH -u "$path"`
14286 
14287   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14288   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14289   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14290   # "foo.exe" is OK but "foo" is an error.
14291   #
14292   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14293   # It is also a way to make sure we got the proper file name for the real test later on.
14294   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14295   if test "x$test_shortpath" = x; then
14296     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14297 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14298     as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
14299   fi
14300 
14301   # Call helper function which possibly converts this using DOS-style short mode.
14302   # If so, the updated path is stored in $new_path.
14303 
14304   input_path="$new_path"
14305   # Check if we need to convert this using DOS-style short mode. If the path
14306   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14307   # take no chances and rewrite it.
14308   # Note: m4 eats our [], so we need to use [ and ] instead.
14309   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14310   if test "x$has_forbidden_chars" != x; then
14311     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14312     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14313     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14314     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14315       # Going to short mode and back again did indeed matter. Since short mode is
14316       # case insensitive, let's make it lowercase to improve readability.
14317       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14318       # Now convert it back to Unix-stile (cygpath)
14319       input_path=`$CYGPATH -u "$shortmode_path"`
14320       new_path="$input_path"
14321     fi
14322   fi
14323 
14324   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14325   if test "x$test_cygdrive_prefix" = x; then
14326     # As a simple fix, exclude /usr/bin since it's not a real path.
14327     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14328       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14329       # a path prefixed by /cygdrive for fixpath to work.
14330       new_path="$CYGWIN_ROOT_PATH$input_path"
14331     fi
14332   fi
14333 
14334 
14335   if test "x$path" != "x$new_path"; then
14336     with_devkit="$new_path"
14337     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14338 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14339   fi
14340 
14341   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14342 
14343   path="$with_devkit"
14344   has_colon=`$ECHO $path | $GREP ^.:`
14345   new_path="$path"
14346   if test "x$has_colon" = x; then
14347     # Not in mixed or Windows style, start by that.
14348     new_path=`cmd //c echo $path`
14349   fi
14350 
14351 
14352   input_path="$new_path"
14353   # Check if we need to convert this using DOS-style short mode. If the path
14354   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14355   # take no chances and rewrite it.
14356   # Note: m4 eats our [], so we need to use [ and ] instead.
14357   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14358   if test "x$has_forbidden_chars" != x; then
14359     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14360     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14361   fi
14362 
14363 
14364   windows_path="$new_path"
14365   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14366     unix_path=`$CYGPATH -u "$windows_path"`
14367     new_path="$unix_path"
14368   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14369     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14370     new_path="$unix_path"
14371   fi
14372 
14373   if test "x$path" != "x$new_path"; then
14374     with_devkit="$new_path"
14375     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14376 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14377   fi
14378 
14379   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14380   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14381 
14382   else
14383     # We're on a posix platform. Hooray! :)
14384     path="$with_devkit"
14385     has_space=`$ECHO "$path" | $GREP " "`
14386     if test "x$has_space" != x; then
14387       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14388 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14389       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14390     fi
14391 
14392     # Use eval to expand a potential ~
14393     eval path="$path"
14394     if test ! -f "$path" && test ! -d "$path"; then
14395       as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
14396     fi
14397 
14398     with_devkit="`cd "$path"; $THEPWDCMD -L`"
14399   fi
14400 






















14401 
14402   if test "x$TOOLS_DIR" = x; then
14403     TOOLS_DIR="$with_devkit/bin"

14404   else
14405     TOOLS_DIR="$TOOLS_DIR:$with_devkit/bin"



14406   fi
14407 
14408         if test -d "$with_devkit/$host_alias/libc"; then
14409           SYS_ROOT=$with_devkit/$host_alias/libc
14410         elif test -d "$with_devkit/$host/sys-root"; then
14411           SYS_ROOT=$with_devkit/$host/sys-root
14412         fi
14413 





























14414 fi
14415 
14416 
14417 





















































































14418   # Setup default logging of stdout and stderr to build.log in the output root.
14419   BUILD_LOG='$(OUTPUT_ROOT)/build.log'
14420   BUILD_LOG_PREVIOUS='$(OUTPUT_ROOT)/build.log.old'
14421   BUILD_LOG_WRAPPER='$(BASH) $(SRC_ROOT)/common/bin/logger.sh $(BUILD_LOG)'
14422 
14423 
14424 
14425 
14426 
14427 # Check if it's a pure open build or if custom sources are to be used.
14428 
14429   # Check whether --enable-openjdk-only was given.
14430 if test "${enable_openjdk_only+set}" = set; then :
14431   enableval=$enable_openjdk_only;
14432 else
14433   enable_openjdk_only="no"
14434 fi
14435 
14436 
14437   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
14438 $as_echo_n "checking for presence of closed sources... " >&6; }
14439   if test -d "$SRC_ROOT/jdk/src/closed"; then
14440     CLOSED_SOURCE_PRESENT=yes
14441   else
14442     CLOSED_SOURCE_PRESENT=no
14443   fi
14444   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
14445 $as_echo "$CLOSED_SOURCE_PRESENT" >&6; }
14446 
14447   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
14448 $as_echo_n "checking if closed source is suppressed (openjdk-only)... " >&6; }
14449   SUPPRESS_CLOSED_SOURCE="$enable_openjdk_only"
14450   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
14451 $as_echo "$SUPPRESS_CLOSED_SOURCE" >&6; }
14452 
14453   if test "x$CLOSED_SOURCE_PRESENT" = xno; then
14454     OPENJDK=true
14455     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14456       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
14457 $as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
14458     fi
14459   else
14460     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14461       OPENJDK=true
14462     else
14463       OPENJDK=false
14464     fi
14465   fi
14466 
14467   if test "x$OPENJDK" = "xtrue"; then
14468     SET_OPENJDK="OPENJDK=true"
14469   fi
14470 
14471 
14472 
14473   # custom-make-dir is deprecated. Please use your custom-hook.m4 to override
14474   # the IncludeCustomExtension macro.
14475 
14476 
14477 # Check whether --with-custom-make-dir was given.
14478 if test "${with_custom_make_dir+set}" = set; then :
14479   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
14480 $as_echo "$as_me: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&2;}
14481 fi
14482 
14483 
14484 
14485 
14486 # These are needed to be able to create a configuration name (and thus the output directory)
14487 
14488   ###############################################################################
14489   #
14490   # Check which variant of the JDK that we want to build.
14491   # Currently we have:
14492   #    normal:   standard edition
14493   # but the custom make system may add other variants
14494   #
14495   # Effectively the JDK variant gives a name to a specific set of
14496   # modules to compile into the JDK. In the future, these modules
14497   # might even be Jigsaw modules.
14498   #
14499   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
14500 $as_echo_n "checking which variant of the JDK to build... " >&6; }
14501 
14502 # Check whether --with-jdk-variant was given.
14503 if test "${with_jdk_variant+set}" = set; then :
14504   withval=$with_jdk_variant;
14505 fi
14506 
14507 
14508   if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
14509     JDK_VARIANT="normal"
14510   else
14511     as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
14512   fi
14513 
14514 
14515 
14516   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
14517 $as_echo "$JDK_VARIANT" >&6; }
14518 
14519 
14520 ###############################################################################
14521 #
14522 # Check which interpreter of the JVM we want to build.
14523 # Currently we have:
14524 #    template: Template interpreter (the default)
14525 #    cpp     : C++ interpreter
14526 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which interpreter of the JVM to build" >&5
14527 $as_echo_n "checking which interpreter of the JVM to build... " >&6; }
14528 
14529 # Check whether --with-jvm-interpreter was given.
14530 if test "${with_jvm_interpreter+set}" = set; then :
14531   withval=$with_jvm_interpreter;
14532 fi
14533 
14534 
14535 if test "x$with_jvm_interpreter" = x; then
14536      with_jvm_interpreter="template"
14537 fi
14538 
14539 JVM_INTERPRETER="$with_jvm_interpreter"
14540 
14541 if test "x$JVM_INTERPRETER" != xtemplate && test "x$JVM_INTERPRETER" != xcpp; then
14542    as_fn_error $? "The available JVM interpreters are: template, cpp" "$LINENO" 5
14543 fi
14544 
14545 
14546 
14547 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_interpreter" >&5
14548 $as_echo "$with_jvm_interpreter" >&6; }
14549 
14550 
14551 
14552   ###############################################################################
14553   #
14554   # Check which variants of the JVM that we want to build.
14555   # Currently we have:
14556   #    server: normal interpreter and a tiered C1/C2 compiler
14557   #    client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms)
14558   #    minimal1: reduced form of client with optional VM services and features stripped out
14559   #    kernel: kernel footprint JVM that passes the TCK without major performance problems,
14560   #             ie normal interpreter and C1, only the serial GC, kernel jvmti etc
14561   #    zero: no machine code interpreter, no compiler
14562   #    zeroshark: zero interpreter and shark/llvm compiler backend
14563 #    core: interpreter only, no compiler (only works on some platforms)
14564   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
14565 $as_echo_n "checking which variants of the JVM to build... " >&6; }
14566 
14567 # Check whether --with-jvm-variants was given.
14568 if test "${with_jvm_variants+set}" = set; then :
14569   withval=$with_jvm_variants;
14570 fi
14571 
14572 
14573   if test "x$with_jvm_variants" = x; then
14574     with_jvm_variants="server"
14575   fi
14576 
14577   JVM_VARIANTS=",$with_jvm_variants,"
14578   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,//'`
14579 
14580   if test "x$TEST_VARIANTS" != "x,"; then
14581      as_fn_error $? "The available JVM variants are: server, client, minimal1, kernel, zero, zeroshark, core" "$LINENO" 5
14582   fi
14583   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5
14584 $as_echo "$with_jvm_variants" >&6; }
14585 
14586   JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'`
14587   JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'`
14588   JVM_VARIANT_MINIMAL1=`$ECHO "$JVM_VARIANTS" | $SED -e '/,minimal1,/!s/.*/false/g' -e '/,minimal1,/s/.*/true/g'`
14589   JVM_VARIANT_KERNEL=`$ECHO "$JVM_VARIANTS" | $SED -e '/,kernel,/!s/.*/false/g' -e '/,kernel,/s/.*/true/g'`
14590   JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'`
14591   JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'`
14592   JVM_VARIANT_CORE=`$ECHO "$JVM_VARIANTS" | $SED -e '/,core,/!s/.*/false/g' -e '/,core,/s/.*/true/g'`
14593 
14594   if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14595     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14596       as_fn_error $? "You cannot build a client JVM for a 64-bit machine." "$LINENO" 5
14597     fi
14598   fi
14599   if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14600     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14601       as_fn_error $? "You cannot build a kernel JVM for a 64-bit machine." "$LINENO" 5
14602     fi
14603   fi
14604   if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14605     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14606       as_fn_error $? "You cannot build a minimal JVM for a 64-bit machine." "$LINENO" 5
14607     fi
14608   fi
14609 
14610   # Replace the commas with AND for use in the build directory name.
14611   ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/g'`
14612   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/'`
14613   if test "x$COUNT_VARIANTS" != "x,1"; then
14614     BUILDING_MULTIPLE_JVM_VARIANTS=yes
14615   else
14616     BUILDING_MULTIPLE_JVM_VARIANTS=no
14617   fi
14618 
14619 
14620 
14621 
14622 
14623 
14624 
14625 
14626 
14627 
14628   INCLUDE_SA=true
14629   if test "x$JVM_VARIANT_ZERO" = xtrue ; then
14630     INCLUDE_SA=false
14631   fi
14632   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue ; then
14633     INCLUDE_SA=false
14634   fi
14635   if test "x$VAR_CPU" = xppc64 ; then
14636     INCLUDE_SA=false
14637   fi
14638 
14639 
14640   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
14641     MACOSX_UNIVERSAL="true"
14642   fi
14643 
14644 
14645 
14646 
14647   ###############################################################################
14648   #
14649   # Set the debug level
14650   #    release: no debug information, all optimizations, no asserts.
14651   #    optimized: no debug information, all optimizations, no asserts, HotSpot target is 'optimized'.
14652   #    fastdebug: debug information (-g), all optimizations, all asserts
14653   #    slowdebug: debug information (-g), no optimizations, all asserts
14654   #
14655   DEBUG_LEVEL="release"
14656   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
14657 $as_echo_n "checking which debug level to use... " >&6; }
14658   # Check whether --enable-debug was given.
14659 if test "${enable_debug+set}" = set; then :
14660   enableval=$enable_debug;
14661         ENABLE_DEBUG="${enableval}"
14662         DEBUG_LEVEL="fastdebug"
14663 
14664 else
14665   ENABLE_DEBUG="no"
14666 fi
14667 
14668 
14669 
14670 # Check whether --with-debug-level was given.
14671 if test "${with_debug_level+set}" = set; then :
14672   withval=$with_debug_level;
14673         DEBUG_LEVEL="${withval}"
14674         if test "x$ENABLE_DEBUG" = xyes; then
14675           as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
14676         fi
14677 
14678 fi
14679 
14680   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
14681 $as_echo "$DEBUG_LEVEL" >&6; }
14682 
14683   if test "x$DEBUG_LEVEL" != xrelease && \
14684       test "x$DEBUG_LEVEL" != xoptimized && \
14685       test "x$DEBUG_LEVEL" != xfastdebug && \
14686       test "x$DEBUG_LEVEL" != xslowdebug; then
14687     as_fn_error $? "Allowed debug levels are: release, fastdebug and slowdebug" "$LINENO" 5
14688   fi
14689 
14690 
14691   ###############################################################################
14692   #
14693   # Setup legacy vars/targets and new vars to deal with different debug levels.
14694   #
14695 
14696   case $DEBUG_LEVEL in
14697     release )
14698       VARIANT="OPT"
14699       FASTDEBUG="false"
14700       DEBUG_CLASSFILES="false"
14701       BUILD_VARIANT_RELEASE=""
14702       HOTSPOT_DEBUG_LEVEL="product"
14703       HOTSPOT_EXPORT="product"
14704       ;;
14705     fastdebug )
14706       VARIANT="DBG"
14707       FASTDEBUG="true"
14708       DEBUG_CLASSFILES="true"
14709       BUILD_VARIANT_RELEASE="-fastdebug"
14710       HOTSPOT_DEBUG_LEVEL="fastdebug"
14711       HOTSPOT_EXPORT="fastdebug"
14712       ;;
14713     slowdebug )
14714       VARIANT="DBG"
14715       FASTDEBUG="false"
14716       DEBUG_CLASSFILES="true"
14717       BUILD_VARIANT_RELEASE="-debug"
14718       HOTSPOT_DEBUG_LEVEL="jvmg"
14719       HOTSPOT_EXPORT="debug"
14720       ;;
14721     optimized )
14722       VARIANT="OPT"
14723       FASTDEBUG="false"
14724       DEBUG_CLASSFILES="false"
14725       BUILD_VARIANT_RELEASE="-optimized"
14726       HOTSPOT_DEBUG_LEVEL="optimized"
14727       HOTSPOT_EXPORT="optimized"
14728       ;;
14729   esac
14730 
14731   # The debug level 'optimized' is a little special because it is currently only
14732   # applicable to the HotSpot build where it means to build a completely
14733   # optimized version of the VM without any debugging code (like for the
14734   # 'release' debug level which is called 'product' in the HotSpot build) but
14735   # with the exception that it can contain additional code which is otherwise
14736   # protected by '#ifndef PRODUCT' macros. These 'optimized' builds are used to
14737   # test new and/or experimental features which are not intended for customer
14738   # shipment. Because these new features need to be tested and benchmarked in
14739   # real world scenarios, we want to build the containing JDK at the 'release'
14740   # debug level.
14741   if test "x$DEBUG_LEVEL" = xoptimized; then
14742     DEBUG_LEVEL="release"
14743   fi
14744 
14745   #####
14746   # Generate the legacy makefile targets for hotspot.
14747   # The hotspot api for selecting the build artifacts, really, needs to be improved.
14748   # JDK-7195896 will fix this on the hotspot side by using the JVM_VARIANT_* variables to
14749   # determine what needs to be built. All we will need to set here is all_product, all_fastdebug etc
14750   # But until then ...
14751   HOTSPOT_TARGET=""
14752 
14753   if test "x$JVM_VARIANT_SERVER" = xtrue; then
14754     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL} "
14755   fi
14756 
14757   if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14758     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}1 "
14759   fi
14760 
14761   if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14762     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}minimal1 "
14763   fi
14764 
14765   if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14766     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}kernel "
14767   fi
14768 
14769   if test "x$JVM_VARIANT_ZERO" = xtrue; then
14770     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}zero "
14771   fi
14772 
14773   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
14774     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}shark "
14775   fi
14776 
14777   if test "x$JVM_VARIANT_CORE" = xtrue; then
14778     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}core "
14779   fi
14780 
14781   HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT"
14782 
14783   # On Macosx universal binaries are produced, but they only contain
14784   # 64 bit intel. This invalidates control of which jvms are built
14785   # from configure, but only server is valid anyway. Fix this
14786   # when hotspot makefiles are rewritten.
14787   if test "x$MACOSX_UNIVERSAL" = xtrue; then
14788     HOTSPOT_TARGET=universal_${HOTSPOT_EXPORT}
14789   fi
14790 
14791   #####
14792 
14793 
14794 
14795 
14796 
14797 
14798 
14799 
14800 # With basic setup done, call the custom early hook.
14801 
14802 
14803 # To properly create a configuration name, we need to have the OpenJDK target
14804 # and options (variants and debug level) parsed.
14805 
14806 
14807 
14808 # Check whether --with-conf-name was given.
14809 if test "${with_conf_name+set}" = set; then :
14810   withval=$with_conf_name;  CONF_NAME=${with_conf_name}
14811 fi
14812 
14813 
14814   # Test from where we are running configure, in or outside of src root.
14815   { $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
14816 $as_echo_n "checking where to store configuration... " >&6; }
14817   if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
14818       || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
14819       || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
14820     # We are running configure from the src root.
14821     # Create a default ./build/target-variant-debuglevel output root.
14822     if test "x${CONF_NAME}" = x; then
14823       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
14824 $as_echo "in default location" >&6; }
14825       CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}"
14826     else
14827       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
14828 $as_echo "in build directory with custom name" >&6; }
14829     fi
14830     OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
14831     $MKDIR -p "$OUTPUT_ROOT"
14832     if test ! -d "$OUTPUT_ROOT"; then
14833       as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
14834     fi
14835   else
14836     # We are running configure from outside of the src dir.
14837     # Then use the current directory as output dir!
14838     # If configuration is situated in normal build directory, just use the build
14839     # directory name as configuration name, otherwise use the complete path.
14840     if test "x${CONF_NAME}" = x; then
14841       CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
14842     fi
14843     OUTPUT_ROOT="$CURDIR"
14844     { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
14845 $as_echo "in current directory" >&6; }
14846 
14847     # WARNING: This might be a bad thing to do. You need to be sure you want to
14848     # have a configuration in this directory. Do some sanity checks!
14849 
14850     if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
14851       # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
14852       # other files
14853       files_present=`$LS $OUTPUT_ROOT`
14854       # Configure has already touched config.log and confdefs.h in the current dir when this check
14855       # is performed.
14856       filtered_files=`$ECHO "$files_present" | $SED -e 's/config.log//g' -e 's/confdefs.h//g' -e 's/ //g' \
14857       | $TR -d '\n'`
14858       if test "x$filtered_files" != x; then
14859         { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
14860 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
14861         { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
14862 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
14863         { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
14864 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
14865         { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
14866 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
14867         { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
14868 $as_echo "$as_me: seriously mess up just about everything." >&6;}
14869         { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
14870 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
14871         { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
14872 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
14873         as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
14874       fi
14875     fi
14876   fi
14877   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
14878 $as_echo_n "checking what configuration name to use... " >&6; }
14879   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
14880 $as_echo "$CONF_NAME" >&6; }
14881 
14882 
14883   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14884 
14885   # Input might be given as Windows format, start by converting to
14886   # unix format.
14887   path="$OUTPUT_ROOT"
14888   new_path=`$CYGPATH -u "$path"`
14889 
14890   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14891   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14892   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14893   # "foo.exe" is OK but "foo" is an error.
14894   #
14895   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14896   # It is also a way to make sure we got the proper file name for the real test later on.
14897   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14898   if test "x$test_shortpath" = x; then
14899     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
14900 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
14901     as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
14902   fi
14903 
14904   # Call helper function which possibly converts this using DOS-style short mode.
14905   # If so, the updated path is stored in $new_path.
14906 
14907   input_path="$new_path"
14908   # Check if we need to convert this using DOS-style short mode. If the path
14909   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14910   # take no chances and rewrite it.
14911   # Note: m4 eats our [], so we need to use [ and ] instead.
14912   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14913   if test "x$has_forbidden_chars" != x; then
14914     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14915     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14916     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14917     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14918       # Going to short mode and back again did indeed matter. Since short mode is
14919       # case insensitive, let's make it lowercase to improve readability.
14920       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14921       # Now convert it back to Unix-stile (cygpath)
14922       input_path=`$CYGPATH -u "$shortmode_path"`
14923       new_path="$input_path"
14924     fi
14925   fi
14926 
14927   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14928   if test "x$test_cygdrive_prefix" = x; then
14929     # As a simple fix, exclude /usr/bin since it's not a real path.
14930     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14931       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14932       # a path prefixed by /cygdrive for fixpath to work.
14933       new_path="$CYGWIN_ROOT_PATH$input_path"
14934     fi
14935   fi
14936 
14937 
14938   if test "x$path" != "x$new_path"; then
14939     OUTPUT_ROOT="$new_path"
14940     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
14941 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
14942   fi
14943 
14944   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14945 
14946   path="$OUTPUT_ROOT"
14947   has_colon=`$ECHO $path | $GREP ^.:`
14948   new_path="$path"
14949   if test "x$has_colon" = x; then
14950     # Not in mixed or Windows style, start by that.
14951     new_path=`cmd //c echo $path`
14952   fi
14953 
14954 
14955   input_path="$new_path"
14956   # Check if we need to convert this using DOS-style short mode. If the path
14957   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14958   # take no chances and rewrite it.
14959   # Note: m4 eats our [], so we need to use [ and ] instead.
14960   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14961   if test "x$has_forbidden_chars" != x; then
14962     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14963     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14964   fi
14965 
14966 
14967   windows_path="$new_path"
14968   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14969     unix_path=`$CYGPATH -u "$windows_path"`
14970     new_path="$unix_path"
14971   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14972     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14973     new_path="$unix_path"
14974   fi
14975 
14976   if test "x$path" != "x$new_path"; then
14977     OUTPUT_ROOT="$new_path"
14978     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
14979 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
14980   fi
14981 
14982   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14983   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14984 
14985   else
14986     # We're on a posix platform. Hooray! :)
14987     path="$OUTPUT_ROOT"
14988     has_space=`$ECHO "$path" | $GREP " "`
14989     if test "x$has_space" != x; then
14990       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
14991 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
14992       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14993     fi
14994 
14995     # Use eval to expand a potential ~
14996     eval path="$path"
14997     if test ! -f "$path" && test ! -d "$path"; then
14998       as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
14999     fi
15000 
15001     OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
15002   fi
15003 
15004 
15005   SPEC=$OUTPUT_ROOT/spec.gmk
15006 
15007   CONF_NAME=$CONF_NAME
15008 
15009   OUTPUT_ROOT=$OUTPUT_ROOT
15010 
15011 
15012   # Most of the probed defines are put into config.h
15013   ac_config_headers="$ac_config_headers $OUTPUT_ROOT/config.h:$AUTOCONF_DIR/config.h.in"
15014 
15015   # The spec.gmk file contains all variables for the make system.
15016   ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
15017 
15018   # The hotspot-spec.gmk file contains legacy variables for the hotspot make system.
15019   ac_config_files="$ac_config_files $OUTPUT_ROOT/hotspot-spec.gmk:$AUTOCONF_DIR/hotspot-spec.gmk.in"
15020 
15021   # The bootcycle-spec.gmk file contains support for boot cycle builds.
15022   ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
15023 
15024   # The compare.sh is used to compare the build output to other builds.
15025   ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
15026 
15027   # Spec.sh is currently used by compare-objects.sh
15028   ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.sh:$AUTOCONF_DIR/spec.sh.in"
15029 
15030   # The generated Makefile knows where the spec.gmk is and where the source is.
15031   # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
15032   # which will look for generated configurations
15033   ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
15034 
15035 
15036 
15037 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
15038 
15039   for ac_prog in apt-get yum port pkgutil pkgadd
15040 do
15041   # Extract the first word of "$ac_prog", so it can be a program name with args.
15042 set dummy $ac_prog; ac_word=$2
15043 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15044 $as_echo_n "checking for $ac_word... " >&6; }
15045 if ${ac_cv_prog_PKGHANDLER+:} false; then :
15046   $as_echo_n "(cached) " >&6
15047 else
15048   if test -n "$PKGHANDLER"; then
15049   ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
15050 else
15051 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15052 for as_dir in $PATH
15053 do
15054   IFS=$as_save_IFS
15055   test -z "$as_dir" && as_dir=.
15056     for ac_exec_ext in '' $ac_executable_extensions; do
15057   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15058     ac_cv_prog_PKGHANDLER="$ac_prog"
15059     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15060     break 2
15061   fi
15062 done
15063   done
15064 IFS=$as_save_IFS
15065 
15066 fi
15067 fi
15068 PKGHANDLER=$ac_cv_prog_PKGHANDLER
15069 if test -n "$PKGHANDLER"; then
15070   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
15071 $as_echo "$PKGHANDLER" >&6; }
15072 else
15073   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15074 $as_echo "no" >&6; }
15075 fi
15076 
15077 
15078   test -n "$PKGHANDLER" && break
15079 done
15080 
15081 
15082 
15083 # Setup tools that requires more complex handling, or that is not needed by the configure script.
15084 
15085 
15086   # We need to find a recent version of GNU make. Especially on Solaris, this can be tricky.
15087   if test "x$MAKE" != x; then
15088     # User has supplied a make, test it.
15089     if test ! -f "$MAKE"; then
15090       as_fn_error $? "The specified make (by MAKE=$MAKE) is not found." "$LINENO" 5
15091     fi
15092 
15093   MAKE_CANDIDATE=""$MAKE""
15094   DESCRIPTION="user supplied MAKE=$MAKE"
15095   if test "x$MAKE_CANDIDATE" != x; then
15096     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15097 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15098     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15099     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15100     if test "x$IS_GNU_MAKE" = x; then
15101       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15102 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15103     else
15104       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15105       if test "x$IS_MODERN_MAKE" = x; then
15106         { $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
15107 $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;}
15108       else
15109         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15110           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15111             MAKE_EXPECTED_ENV='cygwin'
15112           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15113             MAKE_EXPECTED_ENV='msys'
15114           else
15115             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15116           fi
15117           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15118           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15119         else
15120           # Not relevant for non-Windows
15121           IS_MAKE_CORRECT_ENV=true
15122         fi
15123         if test "x$IS_MAKE_CORRECT_ENV" = x; then
15124           { $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
15125 $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;}
15126         else
15127           FOUND_MAKE=$MAKE_CANDIDATE
15128 
15129   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15130 
15131   # First separate the path from the arguments. This will split at the first
15132   # space.
15133   complete="$FOUND_MAKE"
15134   path="${complete%% *}"
15135   tmp="$complete EOL"
15136   arguments="${tmp#* }"
15137 
15138   # Input might be given as Windows format, start by converting to
15139   # unix format.
15140   new_path=`$CYGPATH -u "$path"`
15141 
15142   # Now try to locate executable using which
15143   new_path=`$WHICH "$new_path" 2> /dev/null`
15144   # bat and cmd files are not always considered executable in cygwin causing which
15145   # to not find them
15146   if test "x$new_path" = x \
15147       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15148       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15149     new_path=`$CYGPATH -u "$path"`
15150   fi
15151   if test "x$new_path" = x; then
15152     # Oops. Which didn't find the executable.
15153     # The splitting of arguments from the executable at a space might have been incorrect,
15154     # since paths with space are more likely in Windows. Give it another try with the whole
15155     # argument.
15156     path="$complete"
15157     arguments="EOL"
15158     new_path=`$CYGPATH -u "$path"`
15159     new_path=`$WHICH "$new_path" 2> /dev/null`
15160     # bat and cmd files are not always considered executable in cygwin causing which
15161     # to not find them
15162     if test "x$new_path" = x \
15163         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15164         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15165       new_path=`$CYGPATH -u "$path"`
15166     fi
15167     if test "x$new_path" = x; then
15168       # It's still not found. Now this is an unrecoverable error.
15169       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15170 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15171       has_space=`$ECHO "$complete" | $GREP " "`
15172       if test "x$has_space" != x; then
15173         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15174 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15175       fi
15176       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15177     fi
15178   fi
15179 
15180   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15181   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15182   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15183   # "foo.exe" is OK but "foo" is an error.
15184   #
15185   # This test is therefore slightly more accurate than "test -f" to check for file presence.
15186   # It is also a way to make sure we got the proper file name for the real test later on.
15187   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15188   if test "x$test_shortpath" = x; then
15189     # Short path failed, file does not exist as specified.
15190     # Try adding .exe or .cmd
15191     if test -f "${new_path}.exe"; then
15192       input_to_shortpath="${new_path}.exe"
15193     elif test -f "${new_path}.cmd"; then
15194       input_to_shortpath="${new_path}.cmd"
15195     else
15196       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15197 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15198       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15199 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15200       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15201     fi
15202   else
15203     input_to_shortpath="$new_path"
15204   fi
15205 
15206   # Call helper function which possibly converts this using DOS-style short mode.
15207   # If so, the updated path is stored in $new_path.
15208   new_path="$input_to_shortpath"
15209 
15210   input_path="$input_to_shortpath"
15211   # Check if we need to convert this using DOS-style short mode. If the path
15212   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15213   # take no chances and rewrite it.
15214   # Note: m4 eats our [], so we need to use [ and ] instead.
15215   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15216   if test "x$has_forbidden_chars" != x; then
15217     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15218     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15219     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15220     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15221       # Going to short mode and back again did indeed matter. Since short mode is
15222       # case insensitive, let's make it lowercase to improve readability.
15223       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15224       # Now convert it back to Unix-stile (cygpath)
15225       input_path=`$CYGPATH -u "$shortmode_path"`
15226       new_path="$input_path"
15227     fi
15228   fi
15229 
15230   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15231   if test "x$test_cygdrive_prefix" = x; then
15232     # As a simple fix, exclude /usr/bin since it's not a real path.
15233     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15234       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15235       # a path prefixed by /cygdrive for fixpath to work.
15236       new_path="$CYGWIN_ROOT_PATH$input_path"
15237     fi
15238   fi
15239 
15240   # remove trailing .exe if any
15241   new_path="${new_path/%.exe/}"
15242 
15243   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15244 
15245   # First separate the path from the arguments. This will split at the first
15246   # space.
15247   complete="$FOUND_MAKE"
15248   path="${complete%% *}"
15249   tmp="$complete EOL"
15250   arguments="${tmp#* }"
15251 
15252   # Input might be given as Windows format, start by converting to
15253   # unix format.
15254   new_path="$path"
15255 
15256   windows_path="$new_path"
15257   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15258     unix_path=`$CYGPATH -u "$windows_path"`
15259     new_path="$unix_path"
15260   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15261     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15262     new_path="$unix_path"
15263   fi
15264 
15265 
15266   # Now try to locate executable using which
15267   new_path=`$WHICH "$new_path" 2> /dev/null`
15268 
15269   if test "x$new_path" = x; then
15270     # Oops. Which didn't find the executable.
15271     # The splitting of arguments from the executable at a space might have been incorrect,
15272     # since paths with space are more likely in Windows. Give it another try with the whole
15273     # argument.
15274     path="$complete"
15275     arguments="EOL"
15276     new_path="$path"
15277 
15278   windows_path="$new_path"
15279   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15280     unix_path=`$CYGPATH -u "$windows_path"`
15281     new_path="$unix_path"
15282   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15283     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15284     new_path="$unix_path"
15285   fi
15286 
15287 
15288     new_path=`$WHICH "$new_path" 2> /dev/null`
15289 
15290     if test "x$new_path" = x; then
15291       # It's still not found. Now this is an unrecoverable error.
15292       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15293 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15294       has_space=`$ECHO "$complete" | $GREP " "`
15295       if test "x$has_space" != x; then
15296         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15297 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15298       fi
15299       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15300     fi
15301   fi
15302 
15303   # Now new_path has a complete unix path to the binary
15304   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15305     # Keep paths in /bin as-is, but remove trailing .exe if any
15306     new_path="${new_path/%.exe/}"
15307     # Do not save /bin paths to all_fixpath_prefixes!
15308   else
15309     # Not in mixed or Windows style, start by that.
15310     new_path=`cmd //c echo $new_path`
15311 
15312   input_path="$new_path"
15313   # Check if we need to convert this using DOS-style short mode. If the path
15314   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15315   # take no chances and rewrite it.
15316   # Note: m4 eats our [], so we need to use [ and ] instead.
15317   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15318   if test "x$has_forbidden_chars" != x; then
15319     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15320     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15321   fi
15322 
15323     # Output is in $new_path
15324 
15325   windows_path="$new_path"
15326   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15327     unix_path=`$CYGPATH -u "$windows_path"`
15328     new_path="$unix_path"
15329   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15330     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15331     new_path="$unix_path"
15332   fi
15333 
15334     # remove trailing .exe if any
15335     new_path="${new_path/%.exe/}"
15336 
15337     # Save the first 10 bytes of this path to the storage, so fixpath can work.
15338     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15339   fi
15340 
15341   else
15342     # We're on a posix platform. Hooray! :)
15343     # First separate the path from the arguments. This will split at the first
15344     # space.
15345     complete="$FOUND_MAKE"
15346     path="${complete%% *}"
15347     tmp="$complete EOL"
15348     arguments="${tmp#* }"
15349 
15350     # Cannot rely on the command "which" here since it doesn't always work.
15351     is_absolute_path=`$ECHO "$path" | $GREP ^/`
15352     if test -z "$is_absolute_path"; then
15353       # Path to executable is not absolute. Find it.
15354       IFS_save="$IFS"
15355       IFS=:
15356       for p in $PATH; do
15357         if test -f "$p/$path" && test -x "$p/$path"; then
15358           new_path="$p/$path"
15359           break
15360         fi
15361       done
15362       IFS="$IFS_save"
15363     else
15364       # This is an absolute path, we can use it without further modifications.
15365       new_path="$path"
15366     fi
15367 
15368     if test "x$new_path" = x; then
15369       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15370 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15371       has_space=`$ECHO "$complete" | $GREP " "`
15372       if test "x$has_space" != x; then
15373         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
15374 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
15375       fi
15376       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15377     fi
15378   fi
15379 
15380   # Now join together the path and the arguments once again
15381   if test "x$arguments" != xEOL; then
15382     new_complete="$new_path ${arguments% *}"
15383   else
15384     new_complete="$new_path"
15385   fi
15386 
15387   if test "x$complete" != "x$new_complete"; then
15388     FOUND_MAKE="$new_complete"
15389     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
15390 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
15391   fi
15392 
15393         fi
15394       fi
15395     fi
15396   fi
15397 
15398     if test "x$FOUND_MAKE" = x; then
15399       as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make 3.81 or newer." "$LINENO" 5
15400     fi
15401   else
15402     # Try our hardest to locate a correct version of GNU make
15403     for ac_prog in gmake
15404 do
15405   # Extract the first word of "$ac_prog", so it can be a program name with args.
15406 set dummy $ac_prog; ac_word=$2
15407 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15408 $as_echo_n "checking for $ac_word... " >&6; }
15409 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
15410   $as_echo_n "(cached) " >&6
15411 else
15412   case $CHECK_GMAKE in
15413   [\\/]* | ?:[\\/]*)
15414   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
15415   ;;
15416   *)
15417   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15418 for as_dir in $PATH
15419 do
15420   IFS=$as_save_IFS
15421   test -z "$as_dir" && as_dir=.
15422     for ac_exec_ext in '' $ac_executable_extensions; do
15423   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15424     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
15425     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15426     break 2
15427   fi
15428 done
15429   done
15430 IFS=$as_save_IFS
15431 
15432   ;;
15433 esac
15434 fi
15435 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
15436 if test -n "$CHECK_GMAKE"; then
15437   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
15438 $as_echo "$CHECK_GMAKE" >&6; }
15439 else
15440   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15441 $as_echo "no" >&6; }
15442 fi
15443 
15444 
15445   test -n "$CHECK_GMAKE" && break
15446 done
15447 
15448 
15449   MAKE_CANDIDATE=""$CHECK_GMAKE""
15450   DESCRIPTION="gmake in PATH"
15451   if test "x$MAKE_CANDIDATE" != x; then
15452     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15453 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15454     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15455     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15456     if test "x$IS_GNU_MAKE" = x; then
15457       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15458 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15459     else
15460       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15461       if test "x$IS_MODERN_MAKE" = x; then
15462         { $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
15463 $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;}
15464       else
15465         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15466           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15467             MAKE_EXPECTED_ENV='cygwin'
15468           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15469             MAKE_EXPECTED_ENV='msys'
15470           else
15471             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15472           fi
15473           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15474           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15475         else
15476           # Not relevant for non-Windows
15477           IS_MAKE_CORRECT_ENV=true
15478         fi
15479         if test "x$IS_MAKE_CORRECT_ENV" = x; then
15480           { $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
15481 $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;}
15482         else
15483           FOUND_MAKE=$MAKE_CANDIDATE
15484 
15485   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15486 
15487   # First separate the path from the arguments. This will split at the first
15488   # space.
15489   complete="$FOUND_MAKE"
15490   path="${complete%% *}"
15491   tmp="$complete EOL"
15492   arguments="${tmp#* }"
15493 
15494   # Input might be given as Windows format, start by converting to
15495   # unix format.
15496   new_path=`$CYGPATH -u "$path"`
15497 
15498   # Now try to locate executable using which
15499   new_path=`$WHICH "$new_path" 2> /dev/null`
15500   # bat and cmd files are not always considered executable in cygwin causing which
15501   # to not find them
15502   if test "x$new_path" = x \
15503       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15504       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15505     new_path=`$CYGPATH -u "$path"`
15506   fi
15507   if test "x$new_path" = x; then
15508     # Oops. Which didn't find the executable.
15509     # The splitting of arguments from the executable at a space might have been incorrect,
15510     # since paths with space are more likely in Windows. Give it another try with the whole
15511     # argument.
15512     path="$complete"
15513     arguments="EOL"
15514     new_path=`$CYGPATH -u "$path"`
15515     new_path=`$WHICH "$new_path" 2> /dev/null`
15516     # bat and cmd files are not always considered executable in cygwin causing which
15517     # to not find them
15518     if test "x$new_path" = x \
15519         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15520         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15521       new_path=`$CYGPATH -u "$path"`
15522     fi
15523     if test "x$new_path" = x; then
15524       # It's still not found. Now this is an unrecoverable error.
15525       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15526 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15527       has_space=`$ECHO "$complete" | $GREP " "`
15528       if test "x$has_space" != x; then
15529         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15530 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15531       fi
15532       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15533     fi
15534   fi
15535 
15536   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15537   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15538   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15539   # "foo.exe" is OK but "foo" is an error.
15540   #
15541   # This test is therefore slightly more accurate than "test -f" to check for file presence.
15542   # It is also a way to make sure we got the proper file name for the real test later on.
15543   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15544   if test "x$test_shortpath" = x; then
15545     # Short path failed, file does not exist as specified.
15546     # Try adding .exe or .cmd
15547     if test -f "${new_path}.exe"; then
15548       input_to_shortpath="${new_path}.exe"
15549     elif test -f "${new_path}.cmd"; then
15550       input_to_shortpath="${new_path}.cmd"
15551     else
15552       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15553 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15554       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15555 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15556       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15557     fi
15558   else
15559     input_to_shortpath="$new_path"
15560   fi
15561 
15562   # Call helper function which possibly converts this using DOS-style short mode.
15563   # If so, the updated path is stored in $new_path.
15564   new_path="$input_to_shortpath"
15565 
15566   input_path="$input_to_shortpath"
15567   # Check if we need to convert this using DOS-style short mode. If the path
15568   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15569   # take no chances and rewrite it.
15570   # Note: m4 eats our [], so we need to use [ and ] instead.
15571   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15572   if test "x$has_forbidden_chars" != x; then
15573     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15574     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15575     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15576     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15577       # Going to short mode and back again did indeed matter. Since short mode is
15578       # case insensitive, let's make it lowercase to improve readability.
15579       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15580       # Now convert it back to Unix-stile (cygpath)
15581       input_path=`$CYGPATH -u "$shortmode_path"`
15582       new_path="$input_path"
15583     fi
15584   fi
15585 
15586   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15587   if test "x$test_cygdrive_prefix" = x; then
15588     # As a simple fix, exclude /usr/bin since it's not a real path.
15589     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15590       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15591       # a path prefixed by /cygdrive for fixpath to work.
15592       new_path="$CYGWIN_ROOT_PATH$input_path"
15593     fi
15594   fi
15595 
15596   # remove trailing .exe if any
15597   new_path="${new_path/%.exe/}"
15598 
15599   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15600 
15601   # First separate the path from the arguments. This will split at the first
15602   # space.
15603   complete="$FOUND_MAKE"
15604   path="${complete%% *}"
15605   tmp="$complete EOL"
15606   arguments="${tmp#* }"
15607 
15608   # Input might be given as Windows format, start by converting to
15609   # unix format.
15610   new_path="$path"
15611 
15612   windows_path="$new_path"
15613   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15614     unix_path=`$CYGPATH -u "$windows_path"`
15615     new_path="$unix_path"
15616   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15617     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15618     new_path="$unix_path"
15619   fi
15620 
15621 
15622   # Now try to locate executable using which
15623   new_path=`$WHICH "$new_path" 2> /dev/null`
15624 
15625   if test "x$new_path" = x; then
15626     # Oops. Which didn't find the executable.
15627     # The splitting of arguments from the executable at a space might have been incorrect,
15628     # since paths with space are more likely in Windows. Give it another try with the whole
15629     # argument.
15630     path="$complete"
15631     arguments="EOL"
15632     new_path="$path"
15633 
15634   windows_path="$new_path"
15635   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15636     unix_path=`$CYGPATH -u "$windows_path"`
15637     new_path="$unix_path"
15638   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15639     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15640     new_path="$unix_path"
15641   fi
15642 
15643 
15644     new_path=`$WHICH "$new_path" 2> /dev/null`
15645 
15646     if test "x$new_path" = x; then
15647       # It's still not found. Now this is an unrecoverable error.
15648       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15649 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15650       has_space=`$ECHO "$complete" | $GREP " "`
15651       if test "x$has_space" != x; then
15652         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15653 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15654       fi
15655       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15656     fi
15657   fi
15658 
15659   # Now new_path has a complete unix path to the binary
15660   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15661     # Keep paths in /bin as-is, but remove trailing .exe if any
15662     new_path="${new_path/%.exe/}"
15663     # Do not save /bin paths to all_fixpath_prefixes!
15664   else
15665     # Not in mixed or Windows style, start by that.
15666     new_path=`cmd //c echo $new_path`
15667 
15668   input_path="$new_path"
15669   # Check if we need to convert this using DOS-style short mode. If the path
15670   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15671   # take no chances and rewrite it.
15672   # Note: m4 eats our [], so we need to use [ and ] instead.
15673   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15674   if test "x$has_forbidden_chars" != x; then
15675     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15676     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15677   fi
15678 
15679     # Output is in $new_path
15680 
15681   windows_path="$new_path"
15682   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15683     unix_path=`$CYGPATH -u "$windows_path"`
15684     new_path="$unix_path"
15685   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15686     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15687     new_path="$unix_path"
15688   fi
15689 
15690     # remove trailing .exe if any
15691     new_path="${new_path/%.exe/}"
15692 
15693     # Save the first 10 bytes of this path to the storage, so fixpath can work.
15694     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15695   fi
15696 
15697   else
15698     # We're on a posix platform. Hooray! :)
15699     # First separate the path from the arguments. This will split at the first
15700     # space.
15701     complete="$FOUND_MAKE"
15702     path="${complete%% *}"
15703     tmp="$complete EOL"
15704     arguments="${tmp#* }"
15705 
15706     # Cannot rely on the command "which" here since it doesn't always work.
15707     is_absolute_path=`$ECHO "$path" | $GREP ^/`
15708     if test -z "$is_absolute_path"; then
15709       # Path to executable is not absolute. Find it.
15710       IFS_save="$IFS"
15711       IFS=:
15712       for p in $PATH; do
15713         if test -f "$p/$path" && test -x "$p/$path"; then
15714           new_path="$p/$path"
15715           break
15716         fi
15717       done
15718       IFS="$IFS_save"
15719     else
15720       # This is an absolute path, we can use it without further modifications.
15721       new_path="$path"
15722     fi
15723 
15724     if test "x$new_path" = x; then
15725       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15726 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15727       has_space=`$ECHO "$complete" | $GREP " "`
15728       if test "x$has_space" != x; then
15729         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
15730 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
15731       fi
15732       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15733     fi
15734   fi
15735 
15736   # Now join together the path and the arguments once again
15737   if test "x$arguments" != xEOL; then
15738     new_complete="$new_path ${arguments% *}"
15739   else
15740     new_complete="$new_path"
15741   fi
15742 
15743   if test "x$complete" != "x$new_complete"; then
15744     FOUND_MAKE="$new_complete"
15745     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
15746 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
15747   fi
15748 
15749         fi
15750       fi
15751     fi
15752   fi
15753 
15754 
15755     if test "x$FOUND_MAKE" = x; then
15756       for ac_prog in make
15757 do
15758   # Extract the first word of "$ac_prog", so it can be a program name with args.
15759 set dummy $ac_prog; ac_word=$2
15760 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15761 $as_echo_n "checking for $ac_word... " >&6; }
15762 if ${ac_cv_path_CHECK_MAKE+:} false; then :
15763   $as_echo_n "(cached) " >&6
15764 else
15765   case $CHECK_MAKE in
15766   [\\/]* | ?:[\\/]*)
15767   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
15768   ;;
15769   *)
15770   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15771 for as_dir in $PATH
15772 do
15773   IFS=$as_save_IFS
15774   test -z "$as_dir" && as_dir=.
15775     for ac_exec_ext in '' $ac_executable_extensions; do
15776   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15777     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
15778     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15779     break 2
15780   fi
15781 done
15782   done
15783 IFS=$as_save_IFS
15784 
15785   ;;
15786 esac
15787 fi
15788 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
15789 if test -n "$CHECK_MAKE"; then
15790   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
15791 $as_echo "$CHECK_MAKE" >&6; }
15792 else
15793   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15794 $as_echo "no" >&6; }
15795 fi
15796 
15797 
15798   test -n "$CHECK_MAKE" && break
15799 done
15800 
15801 
15802   MAKE_CANDIDATE=""$CHECK_MAKE""
15803   DESCRIPTION="make in PATH"
15804   if test "x$MAKE_CANDIDATE" != x; then
15805     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15806 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15807     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15808     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15809     if test "x$IS_GNU_MAKE" = x; then
15810       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15811 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15812     else
15813       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15814       if test "x$IS_MODERN_MAKE" = x; then
15815         { $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
15816 $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;}
15817       else
15818         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15819           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15820             MAKE_EXPECTED_ENV='cygwin'
15821           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15822             MAKE_EXPECTED_ENV='msys'
15823           else
15824             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15825           fi
15826           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15827           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15828         else
15829           # Not relevant for non-Windows
15830           IS_MAKE_CORRECT_ENV=true
15831         fi
15832         if test "x$IS_MAKE_CORRECT_ENV" = x; then
15833           { $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
15834 $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;}
15835         else
15836           FOUND_MAKE=$MAKE_CANDIDATE
15837 
15838   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15839 
15840   # First separate the path from the arguments. This will split at the first
15841   # space.
15842   complete="$FOUND_MAKE"
15843   path="${complete%% *}"
15844   tmp="$complete EOL"
15845   arguments="${tmp#* }"
15846 
15847   # Input might be given as Windows format, start by converting to
15848   # unix format.
15849   new_path=`$CYGPATH -u "$path"`
15850 
15851   # Now try to locate executable using which
15852   new_path=`$WHICH "$new_path" 2> /dev/null`
15853   # bat and cmd files are not always considered executable in cygwin causing which
15854   # to not find them
15855   if test "x$new_path" = x \
15856       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15857       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15858     new_path=`$CYGPATH -u "$path"`
15859   fi
15860   if test "x$new_path" = x; then
15861     # Oops. Which didn't find the executable.
15862     # The splitting of arguments from the executable at a space might have been incorrect,
15863     # since paths with space are more likely in Windows. Give it another try with the whole
15864     # argument.
15865     path="$complete"
15866     arguments="EOL"
15867     new_path=`$CYGPATH -u "$path"`
15868     new_path=`$WHICH "$new_path" 2> /dev/null`
15869     # bat and cmd files are not always considered executable in cygwin causing which
15870     # to not find them
15871     if test "x$new_path" = x \
15872         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15873         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15874       new_path=`$CYGPATH -u "$path"`
15875     fi
15876     if test "x$new_path" = x; then
15877       # It's still not found. Now this is an unrecoverable error.
15878       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15879 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15880       has_space=`$ECHO "$complete" | $GREP " "`
15881       if test "x$has_space" != x; then
15882         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15883 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15884       fi
15885       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15886     fi
15887   fi
15888 
15889   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15890   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15891   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15892   # "foo.exe" is OK but "foo" is an error.
15893   #
15894   # This test is therefore slightly more accurate than "test -f" to check for file presence.
15895   # It is also a way to make sure we got the proper file name for the real test later on.
15896   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15897   if test "x$test_shortpath" = x; then
15898     # Short path failed, file does not exist as specified.
15899     # Try adding .exe or .cmd
15900     if test -f "${new_path}.exe"; then
15901       input_to_shortpath="${new_path}.exe"
15902     elif test -f "${new_path}.cmd"; then
15903       input_to_shortpath="${new_path}.cmd"
15904     else
15905       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15906 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15907       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15908 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15909       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15910     fi
15911   else
15912     input_to_shortpath="$new_path"
15913   fi
15914 
15915   # Call helper function which possibly converts this using DOS-style short mode.
15916   # If so, the updated path is stored in $new_path.
15917   new_path="$input_to_shortpath"
15918 
15919   input_path="$input_to_shortpath"
15920   # Check if we need to convert this using DOS-style short mode. If the path
15921   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15922   # take no chances and rewrite it.
15923   # Note: m4 eats our [], so we need to use [ and ] instead.
15924   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15925   if test "x$has_forbidden_chars" != x; then
15926     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15927     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15928     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15929     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15930       # Going to short mode and back again did indeed matter. Since short mode is
15931       # case insensitive, let's make it lowercase to improve readability.
15932       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15933       # Now convert it back to Unix-stile (cygpath)
15934       input_path=`$CYGPATH -u "$shortmode_path"`
15935       new_path="$input_path"
15936     fi
15937   fi
15938 
15939   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15940   if test "x$test_cygdrive_prefix" = x; then
15941     # As a simple fix, exclude /usr/bin since it's not a real path.
15942     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15943       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15944       # a path prefixed by /cygdrive for fixpath to work.
15945       new_path="$CYGWIN_ROOT_PATH$input_path"
15946     fi
15947   fi
15948 
15949   # remove trailing .exe if any
15950   new_path="${new_path/%.exe/}"
15951 
15952   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15953 
15954   # First separate the path from the arguments. This will split at the first
15955   # space.
15956   complete="$FOUND_MAKE"
15957   path="${complete%% *}"
15958   tmp="$complete EOL"
15959   arguments="${tmp#* }"
15960 
15961   # Input might be given as Windows format, start by converting to
15962   # unix format.
15963   new_path="$path"
15964 
15965   windows_path="$new_path"
15966   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15967     unix_path=`$CYGPATH -u "$windows_path"`
15968     new_path="$unix_path"
15969   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15970     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15971     new_path="$unix_path"
15972   fi
15973 
15974 
15975   # Now try to locate executable using which
15976   new_path=`$WHICH "$new_path" 2> /dev/null`
15977 
15978   if test "x$new_path" = x; then
15979     # Oops. Which didn't find the executable.
15980     # The splitting of arguments from the executable at a space might have been incorrect,
15981     # since paths with space are more likely in Windows. Give it another try with the whole
15982     # argument.
15983     path="$complete"
15984     arguments="EOL"
15985     new_path="$path"
15986 
15987   windows_path="$new_path"
15988   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15989     unix_path=`$CYGPATH -u "$windows_path"`
15990     new_path="$unix_path"
15991   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15992     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15993     new_path="$unix_path"
15994   fi
15995 
15996 
15997     new_path=`$WHICH "$new_path" 2> /dev/null`
15998 
15999     if test "x$new_path" = x; then
16000       # It's still not found. Now this is an unrecoverable error.
16001       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16002 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16003       has_space=`$ECHO "$complete" | $GREP " "`
16004       if test "x$has_space" != x; then
16005         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16006 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16007       fi
16008       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16009     fi
16010   fi
16011 
16012   # Now new_path has a complete unix path to the binary
16013   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16014     # Keep paths in /bin as-is, but remove trailing .exe if any
16015     new_path="${new_path/%.exe/}"
16016     # Do not save /bin paths to all_fixpath_prefixes!
16017   else
16018     # Not in mixed or Windows style, start by that.
16019     new_path=`cmd //c echo $new_path`
16020 
16021   input_path="$new_path"
16022   # Check if we need to convert this using DOS-style short mode. If the path
16023   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16024   # take no chances and rewrite it.
16025   # Note: m4 eats our [], so we need to use [ and ] instead.
16026   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16027   if test "x$has_forbidden_chars" != x; then
16028     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16029     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16030   fi
16031 
16032     # Output is in $new_path
16033 
16034   windows_path="$new_path"
16035   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16036     unix_path=`$CYGPATH -u "$windows_path"`
16037     new_path="$unix_path"
16038   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16039     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16040     new_path="$unix_path"
16041   fi
16042 
16043     # remove trailing .exe if any
16044     new_path="${new_path/%.exe/}"
16045 
16046     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16047     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16048   fi
16049 
16050   else
16051     # We're on a posix platform. Hooray! :)
16052     # First separate the path from the arguments. This will split at the first
16053     # space.
16054     complete="$FOUND_MAKE"
16055     path="${complete%% *}"
16056     tmp="$complete EOL"
16057     arguments="${tmp#* }"
16058 
16059     # Cannot rely on the command "which" here since it doesn't always work.
16060     is_absolute_path=`$ECHO "$path" | $GREP ^/`
16061     if test -z "$is_absolute_path"; then
16062       # Path to executable is not absolute. Find it.
16063       IFS_save="$IFS"
16064       IFS=:
16065       for p in $PATH; do
16066         if test -f "$p/$path" && test -x "$p/$path"; then
16067           new_path="$p/$path"
16068           break
16069         fi
16070       done
16071       IFS="$IFS_save"
16072     else
16073       # This is an absolute path, we can use it without further modifications.
16074       new_path="$path"
16075     fi
16076 
16077     if test "x$new_path" = x; then
16078       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16079 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16080       has_space=`$ECHO "$complete" | $GREP " "`
16081       if test "x$has_space" != x; then
16082         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16083 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16084       fi
16085       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16086     fi
16087   fi
16088 
16089   # Now join together the path and the arguments once again
16090   if test "x$arguments" != xEOL; then
16091     new_complete="$new_path ${arguments% *}"
16092   else
16093     new_complete="$new_path"
16094   fi
16095 
16096   if test "x$complete" != "x$new_complete"; then
16097     FOUND_MAKE="$new_complete"
16098     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16099 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16100   fi
16101 
16102         fi
16103       fi
16104     fi
16105   fi
16106 
16107     fi
16108 
16109     if test "x$FOUND_MAKE" = x; then
16110       if test "x$TOOLS_DIR" != x; then
16111         # We have a tools-dir, check that as well before giving up.
16112         OLD_PATH=$PATH
16113         PATH=$TOOLS_DIR:$PATH
16114         for ac_prog in gmake
16115 do
16116   # Extract the first word of "$ac_prog", so it can be a program name with args.
16117 set dummy $ac_prog; ac_word=$2
16118 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16119 $as_echo_n "checking for $ac_word... " >&6; }
16120 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
16121   $as_echo_n "(cached) " >&6
16122 else
16123   case $CHECK_TOOLSDIR_GMAKE in
16124   [\\/]* | ?:[\\/]*)
16125   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
16126   ;;
16127   *)
16128   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16129 for as_dir in $PATH
16130 do
16131   IFS=$as_save_IFS
16132   test -z "$as_dir" && as_dir=.
16133     for ac_exec_ext in '' $ac_executable_extensions; do
16134   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16135     ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
16136     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16137     break 2
16138   fi
16139 done
16140   done
16141 IFS=$as_save_IFS
16142 
16143   ;;
16144 esac
16145 fi
16146 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
16147 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
16148   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
16149 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
16150 else
16151   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16152 $as_echo "no" >&6; }
16153 fi
16154 
16155 
16156   test -n "$CHECK_TOOLSDIR_GMAKE" && break
16157 done
16158 
16159 
16160   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
16161   DESCRIPTION="gmake in tools-dir"
16162   if test "x$MAKE_CANDIDATE" != x; then
16163     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16164 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16165     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16166     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16167     if test "x$IS_GNU_MAKE" = x; then
16168       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16169 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16170     else
16171       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
16172       if test "x$IS_MODERN_MAKE" = x; then
16173         { $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
16174 $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;}
16175       else
16176         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16177           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16178             MAKE_EXPECTED_ENV='cygwin'
16179           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16180             MAKE_EXPECTED_ENV='msys'
16181           else
16182             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16183           fi
16184           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16185           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16186         else
16187           # Not relevant for non-Windows
16188           IS_MAKE_CORRECT_ENV=true
16189         fi
16190         if test "x$IS_MAKE_CORRECT_ENV" = x; then
16191           { $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
16192 $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;}
16193         else
16194           FOUND_MAKE=$MAKE_CANDIDATE
16195 
16196   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16197 
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   # Input might be given as Windows format, start by converting to
16206   # unix format.
16207   new_path=`$CYGPATH -u "$path"`
16208 
16209   # Now try to locate executable using which
16210   new_path=`$WHICH "$new_path" 2> /dev/null`
16211   # bat and cmd files are not always considered executable in cygwin causing which
16212   # to not find them
16213   if test "x$new_path" = x \
16214       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16215       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16216     new_path=`$CYGPATH -u "$path"`
16217   fi
16218   if test "x$new_path" = x; then
16219     # Oops. Which didn't find the executable.
16220     # The splitting of arguments from the executable at a space might have been incorrect,
16221     # since paths with space are more likely in Windows. Give it another try with the whole
16222     # argument.
16223     path="$complete"
16224     arguments="EOL"
16225     new_path=`$CYGPATH -u "$path"`
16226     new_path=`$WHICH "$new_path" 2> /dev/null`
16227     # bat and cmd files are not always considered executable in cygwin causing which
16228     # to not find them
16229     if test "x$new_path" = x \
16230         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16231         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16232       new_path=`$CYGPATH -u "$path"`
16233     fi
16234     if test "x$new_path" = x; then
16235       # It's still not found. Now this is an unrecoverable error.
16236       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16237 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16238       has_space=`$ECHO "$complete" | $GREP " "`
16239       if test "x$has_space" != x; then
16240         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16241 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16242       fi
16243       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16244     fi
16245   fi
16246 
16247   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16248   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16249   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16250   # "foo.exe" is OK but "foo" is an error.
16251   #
16252   # This test is therefore slightly more accurate than "test -f" to check for file presence.
16253   # It is also a way to make sure we got the proper file name for the real test later on.
16254   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16255   if test "x$test_shortpath" = x; then
16256     # Short path failed, file does not exist as specified.
16257     # Try adding .exe or .cmd
16258     if test -f "${new_path}.exe"; then
16259       input_to_shortpath="${new_path}.exe"
16260     elif test -f "${new_path}.cmd"; then
16261       input_to_shortpath="${new_path}.cmd"
16262     else
16263       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16264 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16265       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16266 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16267       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16268     fi
16269   else
16270     input_to_shortpath="$new_path"
16271   fi
16272 
16273   # Call helper function which possibly converts this using DOS-style short mode.
16274   # If so, the updated path is stored in $new_path.
16275   new_path="$input_to_shortpath"
16276 
16277   input_path="$input_to_shortpath"
16278   # Check if we need to convert this using DOS-style short mode. If the path
16279   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16280   # take no chances and rewrite it.
16281   # Note: m4 eats our [], so we need to use [ and ] instead.
16282   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16283   if test "x$has_forbidden_chars" != x; then
16284     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16285     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16286     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16287     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16288       # Going to short mode and back again did indeed matter. Since short mode is
16289       # case insensitive, let's make it lowercase to improve readability.
16290       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16291       # Now convert it back to Unix-stile (cygpath)
16292       input_path=`$CYGPATH -u "$shortmode_path"`
16293       new_path="$input_path"
16294     fi
16295   fi
16296 
16297   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16298   if test "x$test_cygdrive_prefix" = x; then
16299     # As a simple fix, exclude /usr/bin since it's not a real path.
16300     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16301       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16302       # a path prefixed by /cygdrive for fixpath to work.
16303       new_path="$CYGWIN_ROOT_PATH$input_path"
16304     fi
16305   fi
16306 
16307   # remove trailing .exe if any
16308   new_path="${new_path/%.exe/}"
16309 
16310   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16311 
16312   # First separate the path from the arguments. This will split at the first
16313   # space.
16314   complete="$FOUND_MAKE"
16315   path="${complete%% *}"
16316   tmp="$complete EOL"
16317   arguments="${tmp#* }"
16318 
16319   # Input might be given as Windows format, start by converting to
16320   # unix format.
16321   new_path="$path"
16322 
16323   windows_path="$new_path"
16324   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16325     unix_path=`$CYGPATH -u "$windows_path"`
16326     new_path="$unix_path"
16327   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16328     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16329     new_path="$unix_path"
16330   fi
16331 
16332 
16333   # Now try to locate executable using which
16334   new_path=`$WHICH "$new_path" 2> /dev/null`
16335 
16336   if test "x$new_path" = x; then
16337     # Oops. Which didn't find the executable.
16338     # The splitting of arguments from the executable at a space might have been incorrect,
16339     # since paths with space are more likely in Windows. Give it another try with the whole
16340     # argument.
16341     path="$complete"
16342     arguments="EOL"
16343     new_path="$path"
16344 
16345   windows_path="$new_path"
16346   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16347     unix_path=`$CYGPATH -u "$windows_path"`
16348     new_path="$unix_path"
16349   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16350     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16351     new_path="$unix_path"
16352   fi
16353 
16354 
16355     new_path=`$WHICH "$new_path" 2> /dev/null`
16356 
16357     if test "x$new_path" = x; then
16358       # It's still not found. Now this is an unrecoverable error.
16359       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16360 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16361       has_space=`$ECHO "$complete" | $GREP " "`
16362       if test "x$has_space" != x; then
16363         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16364 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16365       fi
16366       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16367     fi
16368   fi
16369 
16370   # Now new_path has a complete unix path to the binary
16371   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16372     # Keep paths in /bin as-is, but remove trailing .exe if any
16373     new_path="${new_path/%.exe/}"
16374     # Do not save /bin paths to all_fixpath_prefixes!
16375   else
16376     # Not in mixed or Windows style, start by that.
16377     new_path=`cmd //c echo $new_path`
16378 
16379   input_path="$new_path"
16380   # Check if we need to convert this using DOS-style short mode. If the path
16381   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16382   # take no chances and rewrite it.
16383   # Note: m4 eats our [], so we need to use [ and ] instead.
16384   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16385   if test "x$has_forbidden_chars" != x; then
16386     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16387     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16388   fi
16389 
16390     # Output is in $new_path
16391 
16392   windows_path="$new_path"
16393   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16394     unix_path=`$CYGPATH -u "$windows_path"`
16395     new_path="$unix_path"
16396   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16397     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16398     new_path="$unix_path"
16399   fi
16400 
16401     # remove trailing .exe if any
16402     new_path="${new_path/%.exe/}"
16403 
16404     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16405     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16406   fi
16407 
16408   else
16409     # We're on a posix platform. Hooray! :)
16410     # First separate the path from the arguments. This will split at the first
16411     # space.
16412     complete="$FOUND_MAKE"
16413     path="${complete%% *}"
16414     tmp="$complete EOL"
16415     arguments="${tmp#* }"
16416 
16417     # Cannot rely on the command "which" here since it doesn't always work.
16418     is_absolute_path=`$ECHO "$path" | $GREP ^/`
16419     if test -z "$is_absolute_path"; then
16420       # Path to executable is not absolute. Find it.
16421       IFS_save="$IFS"
16422       IFS=:
16423       for p in $PATH; do
16424         if test -f "$p/$path" && test -x "$p/$path"; then
16425           new_path="$p/$path"
16426           break
16427         fi
16428       done
16429       IFS="$IFS_save"
16430     else
16431       # This is an absolute path, we can use it without further modifications.
16432       new_path="$path"
16433     fi
16434 
16435     if test "x$new_path" = x; then
16436       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16437 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16438       has_space=`$ECHO "$complete" | $GREP " "`
16439       if test "x$has_space" != x; then
16440         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16441 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16442       fi
16443       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16444     fi
16445   fi
16446 
16447   # Now join together the path and the arguments once again
16448   if test "x$arguments" != xEOL; then
16449     new_complete="$new_path ${arguments% *}"
16450   else
16451     new_complete="$new_path"
16452   fi
16453 
16454   if test "x$complete" != "x$new_complete"; then
16455     FOUND_MAKE="$new_complete"
16456     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16457 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16458   fi
16459 
16460         fi
16461       fi
16462     fi
16463   fi
16464 
16465         if test "x$FOUND_MAKE" = x; then
16466           for ac_prog in make
16467 do
16468   # Extract the first word of "$ac_prog", so it can be a program name with args.
16469 set dummy $ac_prog; ac_word=$2
16470 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16471 $as_echo_n "checking for $ac_word... " >&6; }
16472 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
16473   $as_echo_n "(cached) " >&6
16474 else
16475   case $CHECK_TOOLSDIR_MAKE in
16476   [\\/]* | ?:[\\/]*)
16477   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
16478   ;;
16479   *)
16480   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16481 for as_dir in $PATH
16482 do
16483   IFS=$as_save_IFS
16484   test -z "$as_dir" && as_dir=.
16485     for ac_exec_ext in '' $ac_executable_extensions; do
16486   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16487     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
16488     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16489     break 2
16490   fi
16491 done
16492   done
16493 IFS=$as_save_IFS
16494 
16495   ;;
16496 esac
16497 fi
16498 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
16499 if test -n "$CHECK_TOOLSDIR_MAKE"; then
16500   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
16501 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
16502 else
16503   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16504 $as_echo "no" >&6; }
16505 fi
16506 
16507 
16508   test -n "$CHECK_TOOLSDIR_MAKE" && break
16509 done
16510 
16511 
16512   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
16513   DESCRIPTION="make in tools-dir"
16514   if test "x$MAKE_CANDIDATE" != x; then
16515     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16516 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16517     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16518     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16519     if test "x$IS_GNU_MAKE" = x; then
16520       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16521 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16522     else
16523       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
16524       if test "x$IS_MODERN_MAKE" = x; then
16525         { $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
16526 $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;}
16527       else
16528         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16529           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16530             MAKE_EXPECTED_ENV='cygwin'
16531           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16532             MAKE_EXPECTED_ENV='msys'
16533           else
16534             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16535           fi
16536           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16537           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16538         else
16539           # Not relevant for non-Windows
16540           IS_MAKE_CORRECT_ENV=true
16541         fi
16542         if test "x$IS_MAKE_CORRECT_ENV" = x; then
16543           { $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
16544 $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;}
16545         else
16546           FOUND_MAKE=$MAKE_CANDIDATE
16547 
16548   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16549 
16550   # First separate the path from the arguments. This will split at the first
16551   # space.
16552   complete="$FOUND_MAKE"
16553   path="${complete%% *}"
16554   tmp="$complete EOL"
16555   arguments="${tmp#* }"
16556 
16557   # Input might be given as Windows format, start by converting to
16558   # unix format.
16559   new_path=`$CYGPATH -u "$path"`
16560 
16561   # Now try to locate executable using which
16562   new_path=`$WHICH "$new_path" 2> /dev/null`
16563   # bat and cmd files are not always considered executable in cygwin causing which
16564   # to not find them
16565   if test "x$new_path" = x \
16566       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16567       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16568     new_path=`$CYGPATH -u "$path"`
16569   fi
16570   if test "x$new_path" = x; then
16571     # Oops. Which didn't find the executable.
16572     # The splitting of arguments from the executable at a space might have been incorrect,
16573     # since paths with space are more likely in Windows. Give it another try with the whole
16574     # argument.
16575     path="$complete"
16576     arguments="EOL"
16577     new_path=`$CYGPATH -u "$path"`
16578     new_path=`$WHICH "$new_path" 2> /dev/null`
16579     # bat and cmd files are not always considered executable in cygwin causing which
16580     # to not find them
16581     if test "x$new_path" = x \
16582         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16583         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16584       new_path=`$CYGPATH -u "$path"`
16585     fi
16586     if test "x$new_path" = x; then
16587       # It's still not found. Now this is an unrecoverable error.
16588       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16589 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16590       has_space=`$ECHO "$complete" | $GREP " "`
16591       if test "x$has_space" != x; then
16592         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16593 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16594       fi
16595       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16596     fi
16597   fi
16598 
16599   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16600   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16601   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16602   # "foo.exe" is OK but "foo" is an error.
16603   #
16604   # This test is therefore slightly more accurate than "test -f" to check for file presence.
16605   # It is also a way to make sure we got the proper file name for the real test later on.
16606   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16607   if test "x$test_shortpath" = x; then
16608     # Short path failed, file does not exist as specified.
16609     # Try adding .exe or .cmd
16610     if test -f "${new_path}.exe"; then
16611       input_to_shortpath="${new_path}.exe"
16612     elif test -f "${new_path}.cmd"; then
16613       input_to_shortpath="${new_path}.cmd"
16614     else
16615       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16616 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16617       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16618 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16619       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16620     fi
16621   else
16622     input_to_shortpath="$new_path"
16623   fi
16624 
16625   # Call helper function which possibly converts this using DOS-style short mode.
16626   # If so, the updated path is stored in $new_path.
16627   new_path="$input_to_shortpath"
16628 
16629   input_path="$input_to_shortpath"
16630   # Check if we need to convert this using DOS-style short mode. If the path
16631   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16632   # take no chances and rewrite it.
16633   # Note: m4 eats our [], so we need to use [ and ] instead.
16634   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16635   if test "x$has_forbidden_chars" != x; then
16636     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16637     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16638     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16639     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16640       # Going to short mode and back again did indeed matter. Since short mode is
16641       # case insensitive, let's make it lowercase to improve readability.
16642       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16643       # Now convert it back to Unix-stile (cygpath)
16644       input_path=`$CYGPATH -u "$shortmode_path"`
16645       new_path="$input_path"
16646     fi
16647   fi
16648 
16649   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16650   if test "x$test_cygdrive_prefix" = x; then
16651     # As a simple fix, exclude /usr/bin since it's not a real path.
16652     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16653       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16654       # a path prefixed by /cygdrive for fixpath to work.
16655       new_path="$CYGWIN_ROOT_PATH$input_path"
16656     fi
16657   fi
16658 
16659   # remove trailing .exe if any
16660   new_path="${new_path/%.exe/}"
16661 
16662   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16663 
16664   # First separate the path from the arguments. This will split at the first
16665   # space.
16666   complete="$FOUND_MAKE"
16667   path="${complete%% *}"
16668   tmp="$complete EOL"
16669   arguments="${tmp#* }"
16670 
16671   # Input might be given as Windows format, start by converting to
16672   # unix format.
16673   new_path="$path"
16674 
16675   windows_path="$new_path"
16676   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16677     unix_path=`$CYGPATH -u "$windows_path"`
16678     new_path="$unix_path"
16679   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16680     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16681     new_path="$unix_path"
16682   fi
16683 
16684 
16685   # Now try to locate executable using which
16686   new_path=`$WHICH "$new_path" 2> /dev/null`
16687 
16688   if test "x$new_path" = x; then
16689     # Oops. Which didn't find the executable.
16690     # The splitting of arguments from the executable at a space might have been incorrect,
16691     # since paths with space are more likely in Windows. Give it another try with the whole
16692     # argument.
16693     path="$complete"
16694     arguments="EOL"
16695     new_path="$path"
16696 
16697   windows_path="$new_path"
16698   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16699     unix_path=`$CYGPATH -u "$windows_path"`
16700     new_path="$unix_path"
16701   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16702     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16703     new_path="$unix_path"
16704   fi
16705 
16706 
16707     new_path=`$WHICH "$new_path" 2> /dev/null`
16708 
16709     if test "x$new_path" = x; then
16710       # It's still not found. Now this is an unrecoverable error.
16711       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16712 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16713       has_space=`$ECHO "$complete" | $GREP " "`
16714       if test "x$has_space" != x; then
16715         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16716 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16717       fi
16718       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16719     fi
16720   fi
16721 
16722   # Now new_path has a complete unix path to the binary
16723   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16724     # Keep paths in /bin as-is, but remove trailing .exe if any
16725     new_path="${new_path/%.exe/}"
16726     # Do not save /bin paths to all_fixpath_prefixes!
16727   else
16728     # Not in mixed or Windows style, start by that.
16729     new_path=`cmd //c echo $new_path`
16730 
16731   input_path="$new_path"
16732   # Check if we need to convert this using DOS-style short mode. If the path
16733   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16734   # take no chances and rewrite it.
16735   # Note: m4 eats our [], so we need to use [ and ] instead.
16736   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16737   if test "x$has_forbidden_chars" != x; then
16738     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16739     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16740   fi
16741 
16742     # Output is in $new_path
16743 
16744   windows_path="$new_path"
16745   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16746     unix_path=`$CYGPATH -u "$windows_path"`
16747     new_path="$unix_path"
16748   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16749     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16750     new_path="$unix_path"
16751   fi
16752 
16753     # remove trailing .exe if any
16754     new_path="${new_path/%.exe/}"
16755 
16756     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16757     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16758   fi
16759 
16760   else
16761     # We're on a posix platform. Hooray! :)
16762     # First separate the path from the arguments. This will split at the first
16763     # space.
16764     complete="$FOUND_MAKE"
16765     path="${complete%% *}"
16766     tmp="$complete EOL"
16767     arguments="${tmp#* }"
16768 
16769     # Cannot rely on the command "which" here since it doesn't always work.
16770     is_absolute_path=`$ECHO "$path" | $GREP ^/`
16771     if test -z "$is_absolute_path"; then
16772       # Path to executable is not absolute. Find it.
16773       IFS_save="$IFS"
16774       IFS=:
16775       for p in $PATH; do
16776         if test -f "$p/$path" && test -x "$p/$path"; then
16777           new_path="$p/$path"
16778           break
16779         fi
16780       done
16781       IFS="$IFS_save"
16782     else
16783       # This is an absolute path, we can use it without further modifications.
16784       new_path="$path"
16785     fi
16786 
16787     if test "x$new_path" = x; then
16788       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16789 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16790       has_space=`$ECHO "$complete" | $GREP " "`
16791       if test "x$has_space" != x; then
16792         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16793 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16794       fi
16795       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16796     fi
16797   fi
16798 
16799   # Now join together the path and the arguments once again
16800   if test "x$arguments" != xEOL; then
16801     new_complete="$new_path ${arguments% *}"
16802   else
16803     new_complete="$new_path"
16804   fi
16805 
16806   if test "x$complete" != "x$new_complete"; then
16807     FOUND_MAKE="$new_complete"
16808     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16809 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16810   fi
16811 
16812         fi
16813       fi
16814     fi
16815   fi
16816 
16817         fi
16818         PATH=$OLD_PATH
16819       fi
16820     fi
16821 
16822     if test "x$FOUND_MAKE" = x; then
16823       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
16824     fi
16825   fi
16826 
16827   MAKE=$FOUND_MAKE
16828 
16829   { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
16830 $as_echo "$as_me: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
16831 
16832 
16833 
16834   # Test if find supports -delete
16835   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
16836 $as_echo_n "checking if find supports -delete... " >&6; }
16837   FIND_DELETE="-delete"
16838 
16839   DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
16840 
16841   echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
16842 
16843   TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
16844   if test -f $DELETEDIR/TestIfFindSupportsDelete; then
16845     # No, it does not.
16846     rm $DELETEDIR/TestIfFindSupportsDelete
16847     FIND_DELETE="-exec rm \{\} \+"
16848     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16849 $as_echo "no" >&6; }
16850   else
16851     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
16852 $as_echo "yes" >&6; }
16853   fi
16854   rmdir $DELETEDIR
16855 
16856 
16857 
16858   # These tools might not be installed by default,
16859   # need hint on how to install them.
16860 
16861 
16862 
16863   # Publish this variable in the help.
16864 
16865 
16866   if test "x$UNZIP" = x; then
16867     # The variable is not set by user, try to locate tool using the code snippet
16868     for ac_prog in unzip
16869 do
16870   # Extract the first word of "$ac_prog", so it can be a program name with args.
16871 set dummy $ac_prog; ac_word=$2
16872 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16873 $as_echo_n "checking for $ac_word... " >&6; }
16874 if ${ac_cv_path_UNZIP+:} false; then :
16875   $as_echo_n "(cached) " >&6
16876 else
16877   case $UNZIP in
16878   [\\/]* | ?:[\\/]*)
16879   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
16880   ;;
16881   *)
16882   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16883 for as_dir in $PATH
16884 do
16885   IFS=$as_save_IFS
16886   test -z "$as_dir" && as_dir=.
16887     for ac_exec_ext in '' $ac_executable_extensions; do
16888   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16889     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
16890     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16891     break 2
16892   fi
16893 done
16894   done
16895 IFS=$as_save_IFS
16896 
16897   ;;
16898 esac
16899 fi
16900 UNZIP=$ac_cv_path_UNZIP
16901 if test -n "$UNZIP"; then
16902   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
16903 $as_echo "$UNZIP" >&6; }
16904 else
16905   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16906 $as_echo "no" >&6; }
16907 fi
16908 
16909 
16910   test -n "$UNZIP" && break
16911 done
16912 
16913   else
16914     # The variable is set, but is it from the command line or the environment?
16915 
16916     # Try to remove the string !UNZIP! from our list.
16917     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
16918     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
16919       # If it failed, the variable was not from the command line. Ignore it,
16920       # but warn the user (except for BASH, which is always set by the calling BASH).
16921       if test "xUNZIP" != xBASH; then
16922         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
16923 $as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
16924       fi
16925       # Try to locate tool using the code snippet
16926       for ac_prog in unzip
16927 do
16928   # Extract the first word of "$ac_prog", so it can be a program name with args.
16929 set dummy $ac_prog; ac_word=$2
16930 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16931 $as_echo_n "checking for $ac_word... " >&6; }
16932 if ${ac_cv_path_UNZIP+:} false; then :
16933   $as_echo_n "(cached) " >&6
16934 else
16935   case $UNZIP in
16936   [\\/]* | ?:[\\/]*)
16937   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
16938   ;;
16939   *)
16940   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16941 for as_dir in $PATH
16942 do
16943   IFS=$as_save_IFS
16944   test -z "$as_dir" && as_dir=.
16945     for ac_exec_ext in '' $ac_executable_extensions; do
16946   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16947     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
16948     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16949     break 2
16950   fi
16951 done
16952   done
16953 IFS=$as_save_IFS
16954 
16955   ;;
16956 esac
16957 fi
16958 UNZIP=$ac_cv_path_UNZIP
16959 if test -n "$UNZIP"; then
16960   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
16961 $as_echo "$UNZIP" >&6; }
16962 else
16963   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16964 $as_echo "no" >&6; }
16965 fi
16966 
16967 
16968   test -n "$UNZIP" && break
16969 done
16970 
16971     else
16972       # If it succeeded, then it was overridden by the user. We will use it
16973       # for the tool.
16974 
16975       # First remove it from the list of overridden variables, so we can test
16976       # for unknown variables in the end.
16977       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
16978 
16979       # Check if the provided tool contains a complete path.
16980       tool_specified="$UNZIP"
16981       tool_basename="${tool_specified##*/}"
16982       if test "x$tool_basename" = "x$tool_specified"; then
16983         # A command without a complete path is provided, search $PATH.
16984         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
16985 $as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
16986         # Extract the first word of "$tool_basename", so it can be a program name with args.
16987 set dummy $tool_basename; ac_word=$2
16988 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16989 $as_echo_n "checking for $ac_word... " >&6; }
16990 if ${ac_cv_path_UNZIP+:} false; then :
16991   $as_echo_n "(cached) " >&6
16992 else
16993   case $UNZIP in
16994   [\\/]* | ?:[\\/]*)
16995   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
16996   ;;
16997   *)
16998   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16999 for as_dir in $PATH
17000 do
17001   IFS=$as_save_IFS
17002   test -z "$as_dir" && as_dir=.
17003     for ac_exec_ext in '' $ac_executable_extensions; do
17004   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17005     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17006     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17007     break 2
17008   fi
17009 done
17010   done
17011 IFS=$as_save_IFS
17012 
17013   ;;
17014 esac
17015 fi
17016 UNZIP=$ac_cv_path_UNZIP
17017 if test -n "$UNZIP"; then
17018   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17019 $as_echo "$UNZIP" >&6; }
17020 else
17021   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17022 $as_echo "no" >&6; }
17023 fi
17024 
17025 
17026         if test "x$UNZIP" = x; then
17027           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17028         fi
17029       else
17030         # Otherwise we believe it is a complete path. Use it as it is.
17031         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
17032 $as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
17033         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
17034 $as_echo_n "checking for UNZIP... " >&6; }
17035         if test ! -x "$tool_specified"; then
17036           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17037 $as_echo "not found" >&6; }
17038           as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17039         fi
17040         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17041 $as_echo "$tool_specified" >&6; }
17042       fi
17043     fi
17044   fi
17045 
17046 
17047 
17048   if test "x$UNZIP" = x; then
17049     as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
17050   fi
17051 
17052 
17053 
17054 
17055 
17056   # Publish this variable in the help.
17057 
17058 
17059   if test "x$ZIP" = x; then
17060     # The variable is not set by user, try to locate tool using the code snippet
17061     for ac_prog in zip
17062 do
17063   # Extract the first word of "$ac_prog", so it can be a program name with args.
17064 set dummy $ac_prog; ac_word=$2
17065 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17066 $as_echo_n "checking for $ac_word... " >&6; }
17067 if ${ac_cv_path_ZIP+:} false; then :
17068   $as_echo_n "(cached) " >&6
17069 else
17070   case $ZIP in
17071   [\\/]* | ?:[\\/]*)
17072   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17073   ;;
17074   *)
17075   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17076 for as_dir in $PATH
17077 do
17078   IFS=$as_save_IFS
17079   test -z "$as_dir" && as_dir=.
17080     for ac_exec_ext in '' $ac_executable_extensions; do
17081   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17082     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17083     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17084     break 2
17085   fi
17086 done
17087   done
17088 IFS=$as_save_IFS
17089 
17090   ;;
17091 esac
17092 fi
17093 ZIP=$ac_cv_path_ZIP
17094 if test -n "$ZIP"; then
17095   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17096 $as_echo "$ZIP" >&6; }
17097 else
17098   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17099 $as_echo "no" >&6; }
17100 fi
17101 
17102 
17103   test -n "$ZIP" && break
17104 done
17105 
17106   else
17107     # The variable is set, but is it from the command line or the environment?
17108 
17109     # Try to remove the string !ZIP! from our list.
17110     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIP!/}
17111     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17112       # If it failed, the variable was not from the command line. Ignore it,
17113       # but warn the user (except for BASH, which is always set by the calling BASH).
17114       if test "xZIP" != xBASH; then
17115         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
17116 $as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
17117       fi
17118       # Try to locate tool using the code snippet
17119       for ac_prog in zip
17120 do
17121   # Extract the first word of "$ac_prog", so it can be a program name with args.
17122 set dummy $ac_prog; ac_word=$2
17123 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17124 $as_echo_n "checking for $ac_word... " >&6; }
17125 if ${ac_cv_path_ZIP+:} false; then :
17126   $as_echo_n "(cached) " >&6
17127 else
17128   case $ZIP in
17129   [\\/]* | ?:[\\/]*)
17130   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17131   ;;
17132   *)
17133   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17134 for as_dir in $PATH
17135 do
17136   IFS=$as_save_IFS
17137   test -z "$as_dir" && as_dir=.
17138     for ac_exec_ext in '' $ac_executable_extensions; do
17139   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17140     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17141     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17142     break 2
17143   fi
17144 done
17145   done
17146 IFS=$as_save_IFS
17147 
17148   ;;
17149 esac
17150 fi
17151 ZIP=$ac_cv_path_ZIP
17152 if test -n "$ZIP"; then
17153   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17154 $as_echo "$ZIP" >&6; }
17155 else
17156   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17157 $as_echo "no" >&6; }
17158 fi
17159 
17160 
17161   test -n "$ZIP" && break
17162 done
17163 
17164     else
17165       # If it succeeded, then it was overridden by the user. We will use it
17166       # for the tool.
17167 
17168       # First remove it from the list of overridden variables, so we can test
17169       # for unknown variables in the end.
17170       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17171 
17172       # Check if the provided tool contains a complete path.
17173       tool_specified="$ZIP"
17174       tool_basename="${tool_specified##*/}"
17175       if test "x$tool_basename" = "x$tool_specified"; then
17176         # A command without a complete path is provided, search $PATH.
17177         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
17178 $as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
17179         # Extract the first word of "$tool_basename", so it can be a program name with args.
17180 set dummy $tool_basename; ac_word=$2
17181 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17182 $as_echo_n "checking for $ac_word... " >&6; }
17183 if ${ac_cv_path_ZIP+:} false; then :
17184   $as_echo_n "(cached) " >&6
17185 else
17186   case $ZIP in
17187   [\\/]* | ?:[\\/]*)
17188   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17189   ;;
17190   *)
17191   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17192 for as_dir in $PATH
17193 do
17194   IFS=$as_save_IFS
17195   test -z "$as_dir" && as_dir=.
17196     for ac_exec_ext in '' $ac_executable_extensions; do
17197   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17198     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17199     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17200     break 2
17201   fi
17202 done
17203   done
17204 IFS=$as_save_IFS
17205 
17206   ;;
17207 esac
17208 fi
17209 ZIP=$ac_cv_path_ZIP
17210 if test -n "$ZIP"; then
17211   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17212 $as_echo "$ZIP" >&6; }
17213 else
17214   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17215 $as_echo "no" >&6; }
17216 fi
17217 
17218 
17219         if test "x$ZIP" = x; then
17220           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17221         fi
17222       else
17223         # Otherwise we believe it is a complete path. Use it as it is.
17224         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
17225 $as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
17226         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
17227 $as_echo_n "checking for ZIP... " >&6; }
17228         if test ! -x "$tool_specified"; then
17229           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17230 $as_echo "not found" >&6; }
17231           as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17232         fi
17233         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17234 $as_echo "$tool_specified" >&6; }
17235       fi
17236     fi
17237   fi
17238 
17239 
17240 
17241   if test "x$ZIP" = x; then
17242     as_fn_error $? "Could not find required tool for ZIP" "$LINENO" 5
17243   fi
17244 
17245 
17246 
17247   # Non-required basic tools
17248 
17249 
17250 
17251   # Publish this variable in the help.
17252 
17253 
17254   if test "x$LDD" = x; then
17255     # The variable is not set by user, try to locate tool using the code snippet
17256     for ac_prog in ldd
17257 do
17258   # Extract the first word of "$ac_prog", so it can be a program name with args.
17259 set dummy $ac_prog; ac_word=$2
17260 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17261 $as_echo_n "checking for $ac_word... " >&6; }
17262 if ${ac_cv_path_LDD+:} false; then :
17263   $as_echo_n "(cached) " >&6
17264 else
17265   case $LDD in
17266   [\\/]* | ?:[\\/]*)
17267   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17268   ;;
17269   *)
17270   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17271 for as_dir in $PATH
17272 do
17273   IFS=$as_save_IFS
17274   test -z "$as_dir" && as_dir=.
17275     for ac_exec_ext in '' $ac_executable_extensions; do
17276   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17277     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17278     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17279     break 2
17280   fi
17281 done
17282   done
17283 IFS=$as_save_IFS
17284 
17285   ;;
17286 esac
17287 fi
17288 LDD=$ac_cv_path_LDD
17289 if test -n "$LDD"; then
17290   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17291 $as_echo "$LDD" >&6; }
17292 else
17293   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17294 $as_echo "no" >&6; }
17295 fi
17296 
17297 
17298   test -n "$LDD" && break
17299 done
17300 
17301   else
17302     # The variable is set, but is it from the command line or the environment?
17303 
17304     # Try to remove the string !LDD! from our list.
17305     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
17306     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17307       # If it failed, the variable was not from the command line. Ignore it,
17308       # but warn the user (except for BASH, which is always set by the calling BASH).
17309       if test "xLDD" != xBASH; then
17310         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
17311 $as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
17312       fi
17313       # Try to locate tool using the code snippet
17314       for ac_prog in ldd
17315 do
17316   # Extract the first word of "$ac_prog", so it can be a program name with args.
17317 set dummy $ac_prog; ac_word=$2
17318 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17319 $as_echo_n "checking for $ac_word... " >&6; }
17320 if ${ac_cv_path_LDD+:} false; then :
17321   $as_echo_n "(cached) " >&6
17322 else
17323   case $LDD in
17324   [\\/]* | ?:[\\/]*)
17325   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17326   ;;
17327   *)
17328   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17329 for as_dir in $PATH
17330 do
17331   IFS=$as_save_IFS
17332   test -z "$as_dir" && as_dir=.
17333     for ac_exec_ext in '' $ac_executable_extensions; do
17334   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17335     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17336     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17337     break 2
17338   fi
17339 done
17340   done
17341 IFS=$as_save_IFS
17342 
17343   ;;
17344 esac
17345 fi
17346 LDD=$ac_cv_path_LDD
17347 if test -n "$LDD"; then
17348   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17349 $as_echo "$LDD" >&6; }
17350 else
17351   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17352 $as_echo "no" >&6; }
17353 fi
17354 
17355 
17356   test -n "$LDD" && break
17357 done
17358 
17359     else
17360       # If it succeeded, then it was overridden by the user. We will use it
17361       # for the tool.
17362 
17363       # First remove it from the list of overridden variables, so we can test
17364       # for unknown variables in the end.
17365       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17366 
17367       # Check if the provided tool contains a complete path.
17368       tool_specified="$LDD"
17369       tool_basename="${tool_specified##*/}"
17370       if test "x$tool_basename" = "x$tool_specified"; then
17371         # A command without a complete path is provided, search $PATH.
17372         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
17373 $as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
17374         # Extract the first word of "$tool_basename", so it can be a program name with args.
17375 set dummy $tool_basename; ac_word=$2
17376 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17377 $as_echo_n "checking for $ac_word... " >&6; }
17378 if ${ac_cv_path_LDD+:} false; then :
17379   $as_echo_n "(cached) " >&6
17380 else
17381   case $LDD in
17382   [\\/]* | ?:[\\/]*)
17383   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17384   ;;
17385   *)
17386   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17387 for as_dir in $PATH
17388 do
17389   IFS=$as_save_IFS
17390   test -z "$as_dir" && as_dir=.
17391     for ac_exec_ext in '' $ac_executable_extensions; do
17392   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17393     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17394     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17395     break 2
17396   fi
17397 done
17398   done
17399 IFS=$as_save_IFS
17400 
17401   ;;
17402 esac
17403 fi
17404 LDD=$ac_cv_path_LDD
17405 if test -n "$LDD"; then
17406   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17407 $as_echo "$LDD" >&6; }
17408 else
17409   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17410 $as_echo "no" >&6; }
17411 fi
17412 
17413 
17414         if test "x$LDD" = x; then
17415           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17416         fi
17417       else
17418         # Otherwise we believe it is a complete path. Use it as it is.
17419         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
17420 $as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
17421         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
17422 $as_echo_n "checking for LDD... " >&6; }
17423         if test ! -x "$tool_specified"; then
17424           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17425 $as_echo "not found" >&6; }
17426           as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
17427         fi
17428         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17429 $as_echo "$tool_specified" >&6; }
17430       fi
17431     fi
17432   fi
17433 
17434 
17435   if test "x$LDD" = "x"; then
17436     # List shared lib dependencies is used for
17437     # debug output and checking for forbidden dependencies.
17438     # We can build without it.
17439     LDD="true"
17440   fi
17441 
17442 
17443   # Publish this variable in the help.
17444 
17445 
17446   if test "x$OTOOL" = x; then
17447     # The variable is not set by user, try to locate tool using the code snippet
17448     for ac_prog in otool
17449 do
17450   # Extract the first word of "$ac_prog", so it can be a program name with args.
17451 set dummy $ac_prog; ac_word=$2
17452 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17453 $as_echo_n "checking for $ac_word... " >&6; }
17454 if ${ac_cv_path_OTOOL+:} false; then :
17455   $as_echo_n "(cached) " >&6
17456 else
17457   case $OTOOL in
17458   [\\/]* | ?:[\\/]*)
17459   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
17460   ;;
17461   *)
17462   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17463 for as_dir in $PATH
17464 do
17465   IFS=$as_save_IFS
17466   test -z "$as_dir" && as_dir=.
17467     for ac_exec_ext in '' $ac_executable_extensions; do
17468   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17469     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
17470     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17471     break 2
17472   fi
17473 done
17474   done
17475 IFS=$as_save_IFS
17476 
17477   ;;
17478 esac
17479 fi
17480 OTOOL=$ac_cv_path_OTOOL
17481 if test -n "$OTOOL"; then
17482   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
17483 $as_echo "$OTOOL" >&6; }
17484 else
17485   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17486 $as_echo "no" >&6; }
17487 fi
17488 
17489 
17490   test -n "$OTOOL" && break
17491 done
17492 
17493   else
17494     # The variable is set, but is it from the command line or the environment?
17495 
17496     # Try to remove the string !OTOOL! from our list.
17497     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OTOOL!/}
17498     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17499       # If it failed, the variable was not from the command line. Ignore it,
17500       # but warn the user (except for BASH, which is always set by the calling BASH).
17501       if test "xOTOOL" != xBASH; then
17502         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&5
17503 $as_echo "$as_me: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&2;}
17504       fi
17505       # Try to locate tool using the code snippet
17506       for ac_prog in otool
17507 do
17508   # Extract the first word of "$ac_prog", so it can be a program name with args.
17509 set dummy $ac_prog; ac_word=$2
17510 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17511 $as_echo_n "checking for $ac_word... " >&6; }
17512 if ${ac_cv_path_OTOOL+:} false; then :
17513   $as_echo_n "(cached) " >&6
17514 else
17515   case $OTOOL in
17516   [\\/]* | ?:[\\/]*)
17517   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
17518   ;;
17519   *)
17520   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17521 for as_dir in $PATH
17522 do
17523   IFS=$as_save_IFS
17524   test -z "$as_dir" && as_dir=.
17525     for ac_exec_ext in '' $ac_executable_extensions; do
17526   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17527     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
17528     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17529     break 2
17530   fi
17531 done
17532   done
17533 IFS=$as_save_IFS
17534 
17535   ;;
17536 esac
17537 fi
17538 OTOOL=$ac_cv_path_OTOOL
17539 if test -n "$OTOOL"; then
17540   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
17541 $as_echo "$OTOOL" >&6; }
17542 else
17543   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17544 $as_echo "no" >&6; }
17545 fi
17546 
17547 
17548   test -n "$OTOOL" && break
17549 done
17550 
17551     else
17552       # If it succeeded, then it was overridden by the user. We will use it
17553       # for the tool.
17554 
17555       # First remove it from the list of overridden variables, so we can test
17556       # for unknown variables in the end.
17557       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17558 
17559       # Check if the provided tool contains a complete path.
17560       tool_specified="$OTOOL"
17561       tool_basename="${tool_specified##*/}"
17562       if test "x$tool_basename" = "x$tool_specified"; then
17563         # A command without a complete path is provided, search $PATH.
17564         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OTOOL=$tool_basename" >&5
17565 $as_echo "$as_me: Will search for user supplied tool OTOOL=$tool_basename" >&6;}
17566         # Extract the first word of "$tool_basename", so it can be a program name with args.
17567 set dummy $tool_basename; ac_word=$2
17568 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17569 $as_echo_n "checking for $ac_word... " >&6; }
17570 if ${ac_cv_path_OTOOL+:} false; then :
17571   $as_echo_n "(cached) " >&6
17572 else
17573   case $OTOOL in
17574   [\\/]* | ?:[\\/]*)
17575   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
17576   ;;
17577   *)
17578   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17579 for as_dir in $PATH
17580 do
17581   IFS=$as_save_IFS
17582   test -z "$as_dir" && as_dir=.
17583     for ac_exec_ext in '' $ac_executable_extensions; do
17584   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17585     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
17586     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17587     break 2
17588   fi
17589 done
17590   done
17591 IFS=$as_save_IFS
17592 
17593   ;;
17594 esac
17595 fi
17596 OTOOL=$ac_cv_path_OTOOL
17597 if test -n "$OTOOL"; then
17598   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
17599 $as_echo "$OTOOL" >&6; }
17600 else
17601   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17602 $as_echo "no" >&6; }
17603 fi
17604 
17605 
17606         if test "x$OTOOL" = x; then
17607           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17608         fi
17609       else
17610         # Otherwise we believe it is a complete path. Use it as it is.
17611         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OTOOL=$tool_specified" >&5
17612 $as_echo "$as_me: Will use user supplied tool OTOOL=$tool_specified" >&6;}
17613         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
17614 $as_echo_n "checking for OTOOL... " >&6; }
17615         if test ! -x "$tool_specified"; then
17616           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17617 $as_echo "not found" >&6; }
17618           as_fn_error $? "User supplied tool OTOOL=$tool_specified does not exist or is not executable" "$LINENO" 5
17619         fi
17620         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17621 $as_echo "$tool_specified" >&6; }
17622       fi
17623     fi
17624   fi
17625 
17626 
17627   if test "x$OTOOL" = "x"; then
17628     OTOOL="true"
17629   fi
17630 
17631 
17632   # Publish this variable in the help.
17633 
17634 
17635   if test "x$READELF" = x; then
17636     # The variable is not set by user, try to locate tool using the code snippet
17637     for ac_prog in greadelf readelf
17638 do
17639   # Extract the first word of "$ac_prog", so it can be a program name with args.
17640 set dummy $ac_prog; ac_word=$2
17641 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17642 $as_echo_n "checking for $ac_word... " >&6; }
17643 if ${ac_cv_path_READELF+:} false; then :
17644   $as_echo_n "(cached) " >&6
17645 else
17646   case $READELF in
17647   [\\/]* | ?:[\\/]*)
17648   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
17649   ;;
17650   *)
17651   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17652 for as_dir in $PATH
17653 do
17654   IFS=$as_save_IFS
17655   test -z "$as_dir" && as_dir=.
17656     for ac_exec_ext in '' $ac_executable_extensions; do
17657   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17658     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
17659     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17660     break 2
17661   fi
17662 done
17663   done
17664 IFS=$as_save_IFS
17665 
17666   ;;
17667 esac
17668 fi
17669 READELF=$ac_cv_path_READELF
17670 if test -n "$READELF"; then
17671   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
17672 $as_echo "$READELF" >&6; }
17673 else
17674   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17675 $as_echo "no" >&6; }
17676 fi
17677 
17678 
17679   test -n "$READELF" && break
17680 done
17681 
17682   else
17683     # The variable is set, but is it from the command line or the environment?
17684 
17685     # Try to remove the string !READELF! from our list.
17686     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
17687     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17688       # If it failed, the variable was not from the command line. Ignore it,
17689       # but warn the user (except for BASH, which is always set by the calling BASH).
17690       if test "xREADELF" != xBASH; then
17691         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
17692 $as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
17693       fi
17694       # Try to locate tool using the code snippet
17695       for ac_prog in greadelf readelf
17696 do
17697   # Extract the first word of "$ac_prog", so it can be a program name with args.
17698 set dummy $ac_prog; ac_word=$2
17699 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17700 $as_echo_n "checking for $ac_word... " >&6; }
17701 if ${ac_cv_path_READELF+:} false; then :
17702   $as_echo_n "(cached) " >&6
17703 else
17704   case $READELF in
17705   [\\/]* | ?:[\\/]*)
17706   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
17707   ;;
17708   *)
17709   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17710 for as_dir in $PATH
17711 do
17712   IFS=$as_save_IFS
17713   test -z "$as_dir" && as_dir=.
17714     for ac_exec_ext in '' $ac_executable_extensions; do
17715   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17716     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
17717     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17718     break 2
17719   fi
17720 done
17721   done
17722 IFS=$as_save_IFS
17723 
17724   ;;
17725 esac
17726 fi
17727 READELF=$ac_cv_path_READELF
17728 if test -n "$READELF"; then
17729   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
17730 $as_echo "$READELF" >&6; }
17731 else
17732   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17733 $as_echo "no" >&6; }
17734 fi
17735 
17736 
17737   test -n "$READELF" && break
17738 done
17739 
17740     else
17741       # If it succeeded, then it was overridden by the user. We will use it
17742       # for the tool.
17743 
17744       # First remove it from the list of overridden variables, so we can test
17745       # for unknown variables in the end.
17746       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17747 
17748       # Check if the provided tool contains a complete path.
17749       tool_specified="$READELF"
17750       tool_basename="${tool_specified##*/}"
17751       if test "x$tool_basename" = "x$tool_specified"; then
17752         # A command without a complete path is provided, search $PATH.
17753         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
17754 $as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
17755         # Extract the first word of "$tool_basename", so it can be a program name with args.
17756 set dummy $tool_basename; ac_word=$2
17757 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17758 $as_echo_n "checking for $ac_word... " >&6; }
17759 if ${ac_cv_path_READELF+:} false; then :
17760   $as_echo_n "(cached) " >&6
17761 else
17762   case $READELF in
17763   [\\/]* | ?:[\\/]*)
17764   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
17765   ;;
17766   *)
17767   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17768 for as_dir in $PATH
17769 do
17770   IFS=$as_save_IFS
17771   test -z "$as_dir" && as_dir=.
17772     for ac_exec_ext in '' $ac_executable_extensions; do
17773   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17774     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
17775     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17776     break 2
17777   fi
17778 done
17779   done
17780 IFS=$as_save_IFS
17781 
17782   ;;
17783 esac
17784 fi
17785 READELF=$ac_cv_path_READELF
17786 if test -n "$READELF"; then
17787   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
17788 $as_echo "$READELF" >&6; }
17789 else
17790   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17791 $as_echo "no" >&6; }
17792 fi
17793 
17794 
17795         if test "x$READELF" = x; then
17796           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17797         fi
17798       else
17799         # Otherwise we believe it is a complete path. Use it as it is.
17800         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
17801 $as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
17802         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
17803 $as_echo_n "checking for READELF... " >&6; }
17804         if test ! -x "$tool_specified"; then
17805           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17806 $as_echo "not found" >&6; }
17807           as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
17808         fi
17809         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17810 $as_echo "$tool_specified" >&6; }
17811       fi
17812     fi
17813   fi
17814 
17815 
17816 
17817 
17818   # Publish this variable in the help.
17819 
17820 
17821   if test "x$HG" = x; then
17822     # The variable is not set by user, try to locate tool using the code snippet
17823     for ac_prog in hg
17824 do
17825   # Extract the first word of "$ac_prog", so it can be a program name with args.
17826 set dummy $ac_prog; ac_word=$2
17827 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17828 $as_echo_n "checking for $ac_word... " >&6; }
17829 if ${ac_cv_path_HG+:} false; then :
17830   $as_echo_n "(cached) " >&6
17831 else
17832   case $HG in
17833   [\\/]* | ?:[\\/]*)
17834   ac_cv_path_HG="$HG" # Let the user override the test with a path.
17835   ;;
17836   *)
17837   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17838 for as_dir in $PATH
17839 do
17840   IFS=$as_save_IFS
17841   test -z "$as_dir" && as_dir=.
17842     for ac_exec_ext in '' $ac_executable_extensions; do
17843   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17844     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
17845     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17846     break 2
17847   fi
17848 done
17849   done
17850 IFS=$as_save_IFS
17851 
17852   ;;
17853 esac
17854 fi
17855 HG=$ac_cv_path_HG
17856 if test -n "$HG"; then
17857   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
17858 $as_echo "$HG" >&6; }
17859 else
17860   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17861 $as_echo "no" >&6; }
17862 fi
17863 
17864 
17865   test -n "$HG" && break
17866 done
17867 
17868   else
17869     # The variable is set, but is it from the command line or the environment?
17870 
17871     # Try to remove the string !HG! from our list.
17872     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
17873     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17874       # If it failed, the variable was not from the command line. Ignore it,
17875       # but warn the user (except for BASH, which is always set by the calling BASH).
17876       if test "xHG" != xBASH; then
17877         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
17878 $as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
17879       fi
17880       # Try to locate tool using the code snippet
17881       for ac_prog in hg
17882 do
17883   # Extract the first word of "$ac_prog", so it can be a program name with args.
17884 set dummy $ac_prog; ac_word=$2
17885 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17886 $as_echo_n "checking for $ac_word... " >&6; }
17887 if ${ac_cv_path_HG+:} false; then :
17888   $as_echo_n "(cached) " >&6
17889 else
17890   case $HG in
17891   [\\/]* | ?:[\\/]*)
17892   ac_cv_path_HG="$HG" # Let the user override the test with a path.
17893   ;;
17894   *)
17895   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17896 for as_dir in $PATH
17897 do
17898   IFS=$as_save_IFS
17899   test -z "$as_dir" && as_dir=.
17900     for ac_exec_ext in '' $ac_executable_extensions; do
17901   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17902     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
17903     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17904     break 2
17905   fi
17906 done
17907   done
17908 IFS=$as_save_IFS
17909 
17910   ;;
17911 esac
17912 fi
17913 HG=$ac_cv_path_HG
17914 if test -n "$HG"; then
17915   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
17916 $as_echo "$HG" >&6; }
17917 else
17918   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17919 $as_echo "no" >&6; }
17920 fi
17921 
17922 
17923   test -n "$HG" && break
17924 done
17925 
17926     else
17927       # If it succeeded, then it was overridden by the user. We will use it
17928       # for the tool.
17929 
17930       # First remove it from the list of overridden variables, so we can test
17931       # for unknown variables in the end.
17932       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17933 
17934       # Check if the provided tool contains a complete path.
17935       tool_specified="$HG"
17936       tool_basename="${tool_specified##*/}"
17937       if test "x$tool_basename" = "x$tool_specified"; then
17938         # A command without a complete path is provided, search $PATH.
17939         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
17940 $as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
17941         # Extract the first word of "$tool_basename", so it can be a program name with args.
17942 set dummy $tool_basename; ac_word=$2
17943 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17944 $as_echo_n "checking for $ac_word... " >&6; }
17945 if ${ac_cv_path_HG+:} false; then :
17946   $as_echo_n "(cached) " >&6
17947 else
17948   case $HG in
17949   [\\/]* | ?:[\\/]*)
17950   ac_cv_path_HG="$HG" # Let the user override the test with a path.
17951   ;;
17952   *)
17953   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17954 for as_dir in $PATH
17955 do
17956   IFS=$as_save_IFS
17957   test -z "$as_dir" && as_dir=.
17958     for ac_exec_ext in '' $ac_executable_extensions; do
17959   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17960     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
17961     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17962     break 2
17963   fi
17964 done
17965   done
17966 IFS=$as_save_IFS
17967 
17968   ;;
17969 esac
17970 fi
17971 HG=$ac_cv_path_HG
17972 if test -n "$HG"; then
17973   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
17974 $as_echo "$HG" >&6; }
17975 else
17976   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17977 $as_echo "no" >&6; }
17978 fi
17979 
17980 
17981         if test "x$HG" = x; then
17982           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17983         fi
17984       else
17985         # Otherwise we believe it is a complete path. Use it as it is.
17986         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
17987 $as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
17988         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
17989 $as_echo_n "checking for HG... " >&6; }
17990         if test ! -x "$tool_specified"; then
17991           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17992 $as_echo "not found" >&6; }
17993           as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
17994         fi
17995         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17996 $as_echo "$tool_specified" >&6; }
17997       fi
17998     fi
17999   fi
18000 
18001 
18002 
18003 
18004   # Publish this variable in the help.
18005 
18006 
18007   if test "x$STAT" = x; then
18008     # The variable is not set by user, try to locate tool using the code snippet
18009     for ac_prog in stat
18010 do
18011   # Extract the first word of "$ac_prog", so it can be a program name with args.
18012 set dummy $ac_prog; ac_word=$2
18013 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18014 $as_echo_n "checking for $ac_word... " >&6; }
18015 if ${ac_cv_path_STAT+:} false; then :
18016   $as_echo_n "(cached) " >&6
18017 else
18018   case $STAT in
18019   [\\/]* | ?:[\\/]*)
18020   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18021   ;;
18022   *)
18023   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18024 for as_dir in $PATH
18025 do
18026   IFS=$as_save_IFS
18027   test -z "$as_dir" && as_dir=.
18028     for ac_exec_ext in '' $ac_executable_extensions; do
18029   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18030     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18031     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18032     break 2
18033   fi
18034 done
18035   done
18036 IFS=$as_save_IFS
18037 
18038   ;;
18039 esac
18040 fi
18041 STAT=$ac_cv_path_STAT
18042 if test -n "$STAT"; then
18043   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18044 $as_echo "$STAT" >&6; }
18045 else
18046   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18047 $as_echo "no" >&6; }
18048 fi
18049 
18050 
18051   test -n "$STAT" && break
18052 done
18053 
18054   else
18055     # The variable is set, but is it from the command line or the environment?
18056 
18057     # Try to remove the string !STAT! from our list.
18058     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
18059     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18060       # If it failed, the variable was not from the command line. Ignore it,
18061       # but warn the user (except for BASH, which is always set by the calling BASH).
18062       if test "xSTAT" != xBASH; then
18063         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
18064 $as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
18065       fi
18066       # Try to locate tool using the code snippet
18067       for ac_prog in stat
18068 do
18069   # Extract the first word of "$ac_prog", so it can be a program name with args.
18070 set dummy $ac_prog; ac_word=$2
18071 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18072 $as_echo_n "checking for $ac_word... " >&6; }
18073 if ${ac_cv_path_STAT+:} false; then :
18074   $as_echo_n "(cached) " >&6
18075 else
18076   case $STAT in
18077   [\\/]* | ?:[\\/]*)
18078   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18079   ;;
18080   *)
18081   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18082 for as_dir in $PATH
18083 do
18084   IFS=$as_save_IFS
18085   test -z "$as_dir" && as_dir=.
18086     for ac_exec_ext in '' $ac_executable_extensions; do
18087   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18088     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18089     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18090     break 2
18091   fi
18092 done
18093   done
18094 IFS=$as_save_IFS
18095 
18096   ;;
18097 esac
18098 fi
18099 STAT=$ac_cv_path_STAT
18100 if test -n "$STAT"; then
18101   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18102 $as_echo "$STAT" >&6; }
18103 else
18104   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18105 $as_echo "no" >&6; }
18106 fi
18107 
18108 
18109   test -n "$STAT" && break
18110 done
18111 
18112     else
18113       # If it succeeded, then it was overridden by the user. We will use it
18114       # for the tool.
18115 
18116       # First remove it from the list of overridden variables, so we can test
18117       # for unknown variables in the end.
18118       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18119 
18120       # Check if the provided tool contains a complete path.
18121       tool_specified="$STAT"
18122       tool_basename="${tool_specified##*/}"
18123       if test "x$tool_basename" = "x$tool_specified"; then
18124         # A command without a complete path is provided, search $PATH.
18125         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
18126 $as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
18127         # Extract the first word of "$tool_basename", so it can be a program name with args.
18128 set dummy $tool_basename; ac_word=$2
18129 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18130 $as_echo_n "checking for $ac_word... " >&6; }
18131 if ${ac_cv_path_STAT+:} false; then :
18132   $as_echo_n "(cached) " >&6
18133 else
18134   case $STAT in
18135   [\\/]* | ?:[\\/]*)
18136   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18137   ;;
18138   *)
18139   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18140 for as_dir in $PATH
18141 do
18142   IFS=$as_save_IFS
18143   test -z "$as_dir" && as_dir=.
18144     for ac_exec_ext in '' $ac_executable_extensions; do
18145   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18146     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18147     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18148     break 2
18149   fi
18150 done
18151   done
18152 IFS=$as_save_IFS
18153 
18154   ;;
18155 esac
18156 fi
18157 STAT=$ac_cv_path_STAT
18158 if test -n "$STAT"; then
18159   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18160 $as_echo "$STAT" >&6; }
18161 else
18162   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18163 $as_echo "no" >&6; }
18164 fi
18165 
18166 
18167         if test "x$STAT" = x; then
18168           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18169         fi
18170       else
18171         # Otherwise we believe it is a complete path. Use it as it is.
18172         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
18173 $as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
18174         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
18175 $as_echo_n "checking for STAT... " >&6; }
18176         if test ! -x "$tool_specified"; then
18177           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18178 $as_echo "not found" >&6; }
18179           as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
18180         fi
18181         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18182 $as_echo "$tool_specified" >&6; }
18183       fi
18184     fi
18185   fi
18186 
18187 
18188 
18189 
18190   # Publish this variable in the help.
18191 
18192 
18193   if test "x$TIME" = x; then
18194     # The variable is not set by user, try to locate tool using the code snippet
18195     for ac_prog in time
18196 do
18197   # Extract the first word of "$ac_prog", so it can be a program name with args.
18198 set dummy $ac_prog; ac_word=$2
18199 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18200 $as_echo_n "checking for $ac_word... " >&6; }
18201 if ${ac_cv_path_TIME+:} false; then :
18202   $as_echo_n "(cached) " >&6
18203 else
18204   case $TIME in
18205   [\\/]* | ?:[\\/]*)
18206   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18207   ;;
18208   *)
18209   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18210 for as_dir in $PATH
18211 do
18212   IFS=$as_save_IFS
18213   test -z "$as_dir" && as_dir=.
18214     for ac_exec_ext in '' $ac_executable_extensions; do
18215   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18216     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18217     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18218     break 2
18219   fi
18220 done
18221   done
18222 IFS=$as_save_IFS
18223 
18224   ;;
18225 esac
18226 fi
18227 TIME=$ac_cv_path_TIME
18228 if test -n "$TIME"; then
18229   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18230 $as_echo "$TIME" >&6; }
18231 else
18232   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18233 $as_echo "no" >&6; }
18234 fi
18235 
18236 
18237   test -n "$TIME" && break
18238 done
18239 
18240   else
18241     # The variable is set, but is it from the command line or the environment?
18242 
18243     # Try to remove the string !TIME! from our list.
18244     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
18245     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18246       # If it failed, the variable was not from the command line. Ignore it,
18247       # but warn the user (except for BASH, which is always set by the calling BASH).
18248       if test "xTIME" != xBASH; then
18249         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
18250 $as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
18251       fi
18252       # Try to locate tool using the code snippet
18253       for ac_prog in time
18254 do
18255   # Extract the first word of "$ac_prog", so it can be a program name with args.
18256 set dummy $ac_prog; ac_word=$2
18257 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18258 $as_echo_n "checking for $ac_word... " >&6; }
18259 if ${ac_cv_path_TIME+:} false; then :
18260   $as_echo_n "(cached) " >&6
18261 else
18262   case $TIME in
18263   [\\/]* | ?:[\\/]*)
18264   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18265   ;;
18266   *)
18267   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18268 for as_dir in $PATH
18269 do
18270   IFS=$as_save_IFS
18271   test -z "$as_dir" && as_dir=.
18272     for ac_exec_ext in '' $ac_executable_extensions; do
18273   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18274     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18275     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18276     break 2
18277   fi
18278 done
18279   done
18280 IFS=$as_save_IFS
18281 
18282   ;;
18283 esac
18284 fi
18285 TIME=$ac_cv_path_TIME
18286 if test -n "$TIME"; then
18287   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18288 $as_echo "$TIME" >&6; }
18289 else
18290   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18291 $as_echo "no" >&6; }
18292 fi
18293 
18294 
18295   test -n "$TIME" && break
18296 done
18297 
18298     else
18299       # If it succeeded, then it was overridden by the user. We will use it
18300       # for the tool.
18301 
18302       # First remove it from the list of overridden variables, so we can test
18303       # for unknown variables in the end.
18304       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18305 
18306       # Check if the provided tool contains a complete path.
18307       tool_specified="$TIME"
18308       tool_basename="${tool_specified##*/}"
18309       if test "x$tool_basename" = "x$tool_specified"; then
18310         # A command without a complete path is provided, search $PATH.
18311         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
18312 $as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
18313         # Extract the first word of "$tool_basename", so it can be a program name with args.
18314 set dummy $tool_basename; ac_word=$2
18315 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18316 $as_echo_n "checking for $ac_word... " >&6; }
18317 if ${ac_cv_path_TIME+:} false; then :
18318   $as_echo_n "(cached) " >&6
18319 else
18320   case $TIME in
18321   [\\/]* | ?:[\\/]*)
18322   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18323   ;;
18324   *)
18325   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18326 for as_dir in $PATH
18327 do
18328   IFS=$as_save_IFS
18329   test -z "$as_dir" && as_dir=.
18330     for ac_exec_ext in '' $ac_executable_extensions; do
18331   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18332     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18333     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18334     break 2
18335   fi
18336 done
18337   done
18338 IFS=$as_save_IFS
18339 
18340   ;;
18341 esac
18342 fi
18343 TIME=$ac_cv_path_TIME
18344 if test -n "$TIME"; then
18345   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18346 $as_echo "$TIME" >&6; }
18347 else
18348   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18349 $as_echo "no" >&6; }
18350 fi
18351 
18352 
18353         if test "x$TIME" = x; then
18354           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18355         fi
18356       else
18357         # Otherwise we believe it is a complete path. Use it as it is.
18358         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
18359 $as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
18360         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
18361 $as_echo_n "checking for TIME... " >&6; }
18362         if test ! -x "$tool_specified"; then
18363           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18364 $as_echo "not found" >&6; }
18365           as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
18366         fi
18367         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18368 $as_echo "$tool_specified" >&6; }
18369       fi
18370     fi
18371   fi
18372 
18373 
18374   # Check if it's GNU time
18375   IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
18376   if test "x$IS_GNU_TIME" != x; then
18377     IS_GNU_TIME=yes
18378   else
18379     IS_GNU_TIME=no
18380   fi
18381 
18382 
18383   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
18384 
18385 
18386 
18387   # Publish this variable in the help.
18388 
18389 
18390   if test "x$COMM" = x; then
18391     # The variable is not set by user, try to locate tool using the code snippet
18392     for ac_prog in comm
18393 do
18394   # Extract the first word of "$ac_prog", so it can be a program name with args.
18395 set dummy $ac_prog; ac_word=$2
18396 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18397 $as_echo_n "checking for $ac_word... " >&6; }
18398 if ${ac_cv_path_COMM+:} false; then :
18399   $as_echo_n "(cached) " >&6
18400 else
18401   case $COMM in
18402   [\\/]* | ?:[\\/]*)
18403   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
18404   ;;
18405   *)
18406   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18407 for as_dir in $PATH
18408 do
18409   IFS=$as_save_IFS
18410   test -z "$as_dir" && as_dir=.
18411     for ac_exec_ext in '' $ac_executable_extensions; do
18412   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18413     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
18414     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18415     break 2
18416   fi
18417 done
18418   done
18419 IFS=$as_save_IFS
18420 
18421   ;;
18422 esac
18423 fi
18424 COMM=$ac_cv_path_COMM
18425 if test -n "$COMM"; then
18426   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
18427 $as_echo "$COMM" >&6; }
18428 else
18429   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18430 $as_echo "no" >&6; }
18431 fi
18432 
18433 
18434   test -n "$COMM" && break
18435 done
18436 
18437   else
18438     # The variable is set, but is it from the command line or the environment?
18439 
18440     # Try to remove the string !COMM! from our list.
18441     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
18442     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18443       # If it failed, the variable was not from the command line. Ignore it,
18444       # but warn the user (except for BASH, which is always set by the calling BASH).
18445       if test "xCOMM" != xBASH; then
18446         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
18447 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
18448       fi
18449       # Try to locate tool using the code snippet
18450       for ac_prog in comm
18451 do
18452   # Extract the first word of "$ac_prog", so it can be a program name with args.
18453 set dummy $ac_prog; ac_word=$2
18454 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18455 $as_echo_n "checking for $ac_word... " >&6; }
18456 if ${ac_cv_path_COMM+:} false; then :
18457   $as_echo_n "(cached) " >&6
18458 else
18459   case $COMM in
18460   [\\/]* | ?:[\\/]*)
18461   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
18462   ;;
18463   *)
18464   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18465 for as_dir in $PATH
18466 do
18467   IFS=$as_save_IFS
18468   test -z "$as_dir" && as_dir=.
18469     for ac_exec_ext in '' $ac_executable_extensions; do
18470   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18471     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
18472     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18473     break 2
18474   fi
18475 done
18476   done
18477 IFS=$as_save_IFS
18478 
18479   ;;
18480 esac
18481 fi
18482 COMM=$ac_cv_path_COMM
18483 if test -n "$COMM"; then
18484   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
18485 $as_echo "$COMM" >&6; }
18486 else
18487   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18488 $as_echo "no" >&6; }
18489 fi
18490 
18491 
18492   test -n "$COMM" && break
18493 done
18494 
18495     else
18496       # If it succeeded, then it was overridden by the user. We will use it
18497       # for the tool.
18498 
18499       # First remove it from the list of overridden variables, so we can test
18500       # for unknown variables in the end.
18501       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18502 
18503       # Check if the provided tool contains a complete path.
18504       tool_specified="$COMM"
18505       tool_basename="${tool_specified##*/}"
18506       if test "x$tool_basename" = "x$tool_specified"; then
18507         # A command without a complete path is provided, search $PATH.
18508         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
18509 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
18510         # Extract the first word of "$tool_basename", so it can be a program name with args.
18511 set dummy $tool_basename; ac_word=$2
18512 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18513 $as_echo_n "checking for $ac_word... " >&6; }
18514 if ${ac_cv_path_COMM+:} false; then :
18515   $as_echo_n "(cached) " >&6
18516 else
18517   case $COMM in
18518   [\\/]* | ?:[\\/]*)
18519   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
18520   ;;
18521   *)
18522   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18523 for as_dir in $PATH
18524 do
18525   IFS=$as_save_IFS
18526   test -z "$as_dir" && as_dir=.
18527     for ac_exec_ext in '' $ac_executable_extensions; do
18528   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18529     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
18530     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18531     break 2
18532   fi
18533 done
18534   done
18535 IFS=$as_save_IFS
18536 
18537   ;;
18538 esac
18539 fi
18540 COMM=$ac_cv_path_COMM
18541 if test -n "$COMM"; then
18542   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
18543 $as_echo "$COMM" >&6; }
18544 else
18545   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18546 $as_echo "no" >&6; }
18547 fi
18548 
18549 
18550         if test "x$COMM" = x; then
18551           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18552         fi
18553       else
18554         # Otherwise we believe it is a complete path. Use it as it is.
18555         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
18556 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
18557         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
18558 $as_echo_n "checking for COMM... " >&6; }
18559         if test ! -x "$tool_specified"; then
18560           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18561 $as_echo "not found" >&6; }
18562           as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
18563         fi
18564         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18565 $as_echo "$tool_specified" >&6; }
18566       fi
18567     fi
18568   fi
18569 
18570 
18571 
18572   if test "x$COMM" = x; then
18573     as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
18574   fi
18575 
18576 
18577   fi
18578 
18579   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
18580 
18581 
18582 
18583   # Publish this variable in the help.
18584 
18585 
18586   if test "x$DSYMUTIL" = x; then
18587     # The variable is not set by user, try to locate tool using the code snippet
18588     for ac_prog in dsymutil
18589 do
18590   # Extract the first word of "$ac_prog", so it can be a program name with args.
18591 set dummy $ac_prog; ac_word=$2
18592 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18593 $as_echo_n "checking for $ac_word... " >&6; }
18594 if ${ac_cv_path_DSYMUTIL+:} false; then :
18595   $as_echo_n "(cached) " >&6
18596 else
18597   case $DSYMUTIL in
18598   [\\/]* | ?:[\\/]*)
18599   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18600   ;;
18601   *)
18602   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18603 for as_dir in $PATH
18604 do
18605   IFS=$as_save_IFS
18606   test -z "$as_dir" && as_dir=.
18607     for ac_exec_ext in '' $ac_executable_extensions; do
18608   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18609     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18610     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18611     break 2
18612   fi
18613 done
18614   done
18615 IFS=$as_save_IFS
18616 
18617   ;;
18618 esac
18619 fi
18620 DSYMUTIL=$ac_cv_path_DSYMUTIL
18621 if test -n "$DSYMUTIL"; then
18622   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18623 $as_echo "$DSYMUTIL" >&6; }
18624 else
18625   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18626 $as_echo "no" >&6; }
18627 fi
18628 
18629 
18630   test -n "$DSYMUTIL" && break
18631 done
18632 
18633   else
18634     # The variable is set, but is it from the command line or the environment?
18635 
18636     # Try to remove the string !DSYMUTIL! from our list.
18637     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
18638     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18639       # If it failed, the variable was not from the command line. Ignore it,
18640       # but warn the user (except for BASH, which is always set by the calling BASH).
18641       if test "xDSYMUTIL" != xBASH; then
18642         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
18643 $as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
18644       fi
18645       # Try to locate tool using the code snippet
18646       for ac_prog in dsymutil
18647 do
18648   # Extract the first word of "$ac_prog", so it can be a program name with args.
18649 set dummy $ac_prog; ac_word=$2
18650 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18651 $as_echo_n "checking for $ac_word... " >&6; }
18652 if ${ac_cv_path_DSYMUTIL+:} false; then :
18653   $as_echo_n "(cached) " >&6
18654 else
18655   case $DSYMUTIL in
18656   [\\/]* | ?:[\\/]*)
18657   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18658   ;;
18659   *)
18660   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18661 for as_dir in $PATH
18662 do
18663   IFS=$as_save_IFS
18664   test -z "$as_dir" && as_dir=.
18665     for ac_exec_ext in '' $ac_executable_extensions; do
18666   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18667     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18668     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18669     break 2
18670   fi
18671 done
18672   done
18673 IFS=$as_save_IFS
18674 
18675   ;;
18676 esac
18677 fi
18678 DSYMUTIL=$ac_cv_path_DSYMUTIL
18679 if test -n "$DSYMUTIL"; then
18680   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18681 $as_echo "$DSYMUTIL" >&6; }
18682 else
18683   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18684 $as_echo "no" >&6; }
18685 fi
18686 
18687 
18688   test -n "$DSYMUTIL" && break
18689 done
18690 
18691     else
18692       # If it succeeded, then it was overridden by the user. We will use it
18693       # for the tool.
18694 
18695       # First remove it from the list of overridden variables, so we can test
18696       # for unknown variables in the end.
18697       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18698 
18699       # Check if the provided tool contains a complete path.
18700       tool_specified="$DSYMUTIL"
18701       tool_basename="${tool_specified##*/}"
18702       if test "x$tool_basename" = "x$tool_specified"; then
18703         # A command without a complete path is provided, search $PATH.
18704         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
18705 $as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
18706         # Extract the first word of "$tool_basename", so it can be a program name with args.
18707 set dummy $tool_basename; ac_word=$2
18708 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18709 $as_echo_n "checking for $ac_word... " >&6; }
18710 if ${ac_cv_path_DSYMUTIL+:} false; then :
18711   $as_echo_n "(cached) " >&6
18712 else
18713   case $DSYMUTIL in
18714   [\\/]* | ?:[\\/]*)
18715   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18716   ;;
18717   *)
18718   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18719 for as_dir in $PATH
18720 do
18721   IFS=$as_save_IFS
18722   test -z "$as_dir" && as_dir=.
18723     for ac_exec_ext in '' $ac_executable_extensions; do
18724   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18725     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18726     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18727     break 2
18728   fi
18729 done
18730   done
18731 IFS=$as_save_IFS
18732 
18733   ;;
18734 esac
18735 fi
18736 DSYMUTIL=$ac_cv_path_DSYMUTIL
18737 if test -n "$DSYMUTIL"; then
18738   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18739 $as_echo "$DSYMUTIL" >&6; }
18740 else
18741   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18742 $as_echo "no" >&6; }
18743 fi
18744 
18745 
18746         if test "x$DSYMUTIL" = x; then
18747           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18748         fi
18749       else
18750         # Otherwise we believe it is a complete path. Use it as it is.
18751         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
18752 $as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
18753         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
18754 $as_echo_n "checking for DSYMUTIL... " >&6; }
18755         if test ! -x "$tool_specified"; then
18756           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18757 $as_echo "not found" >&6; }
18758           as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
18759         fi
18760         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18761 $as_echo "$tool_specified" >&6; }
18762       fi
18763     fi
18764   fi
18765 
18766 
18767 
18768   if test "x$DSYMUTIL" = x; then
18769     as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
18770   fi
18771 
18772 
18773 
18774 
18775 
18776   # Publish this variable in the help.
18777 
18778 
18779   if test "x$XATTR" = x; then
18780     # The variable is not set by user, try to locate tool using the code snippet
18781     for ac_prog in xattr
18782 do
18783   # Extract the first word of "$ac_prog", so it can be a program name with args.
18784 set dummy $ac_prog; ac_word=$2
18785 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18786 $as_echo_n "checking for $ac_word... " >&6; }
18787 if ${ac_cv_path_XATTR+:} false; then :
18788   $as_echo_n "(cached) " >&6
18789 else
18790   case $XATTR in
18791   [\\/]* | ?:[\\/]*)
18792   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
18793   ;;
18794   *)
18795   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18796 for as_dir in $PATH
18797 do
18798   IFS=$as_save_IFS
18799   test -z "$as_dir" && as_dir=.
18800     for ac_exec_ext in '' $ac_executable_extensions; do
18801   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18802     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
18803     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18804     break 2
18805   fi
18806 done
18807   done
18808 IFS=$as_save_IFS
18809 
18810   ;;
18811 esac
18812 fi
18813 XATTR=$ac_cv_path_XATTR
18814 if test -n "$XATTR"; then
18815   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
18816 $as_echo "$XATTR" >&6; }
18817 else
18818   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18819 $as_echo "no" >&6; }
18820 fi
18821 
18822 
18823   test -n "$XATTR" && break
18824 done
18825 
18826   else
18827     # The variable is set, but is it from the command line or the environment?
18828 
18829     # Try to remove the string !XATTR! from our list.
18830     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
18831     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18832       # If it failed, the variable was not from the command line. Ignore it,
18833       # but warn the user (except for BASH, which is always set by the calling BASH).
18834       if test "xXATTR" != xBASH; then
18835         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
18836 $as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
18837       fi
18838       # Try to locate tool using the code snippet
18839       for ac_prog in xattr
18840 do
18841   # Extract the first word of "$ac_prog", so it can be a program name with args.
18842 set dummy $ac_prog; ac_word=$2
18843 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18844 $as_echo_n "checking for $ac_word... " >&6; }
18845 if ${ac_cv_path_XATTR+:} false; then :
18846   $as_echo_n "(cached) " >&6
18847 else
18848   case $XATTR in
18849   [\\/]* | ?:[\\/]*)
18850   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
18851   ;;
18852   *)
18853   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18854 for as_dir in $PATH
18855 do
18856   IFS=$as_save_IFS
18857   test -z "$as_dir" && as_dir=.
18858     for ac_exec_ext in '' $ac_executable_extensions; do
18859   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18860     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
18861     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18862     break 2
18863   fi
18864 done
18865   done
18866 IFS=$as_save_IFS
18867 
18868   ;;
18869 esac
18870 fi
18871 XATTR=$ac_cv_path_XATTR
18872 if test -n "$XATTR"; then
18873   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
18874 $as_echo "$XATTR" >&6; }
18875 else
18876   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18877 $as_echo "no" >&6; }
18878 fi
18879 
18880 
18881   test -n "$XATTR" && break
18882 done
18883 
18884     else
18885       # If it succeeded, then it was overridden by the user. We will use it
18886       # for the tool.
18887 
18888       # First remove it from the list of overridden variables, so we can test
18889       # for unknown variables in the end.
18890       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18891 
18892       # Check if the provided tool contains a complete path.
18893       tool_specified="$XATTR"
18894       tool_basename="${tool_specified##*/}"
18895       if test "x$tool_basename" = "x$tool_specified"; then
18896         # A command without a complete path is provided, search $PATH.
18897         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
18898 $as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
18899         # Extract the first word of "$tool_basename", so it can be a program name with args.
18900 set dummy $tool_basename; ac_word=$2
18901 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18902 $as_echo_n "checking for $ac_word... " >&6; }
18903 if ${ac_cv_path_XATTR+:} false; then :
18904   $as_echo_n "(cached) " >&6
18905 else
18906   case $XATTR in
18907   [\\/]* | ?:[\\/]*)
18908   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
18909   ;;
18910   *)
18911   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18912 for as_dir in $PATH
18913 do
18914   IFS=$as_save_IFS
18915   test -z "$as_dir" && as_dir=.
18916     for ac_exec_ext in '' $ac_executable_extensions; do
18917   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18918     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
18919     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18920     break 2
18921   fi
18922 done
18923   done
18924 IFS=$as_save_IFS
18925 
18926   ;;
18927 esac
18928 fi
18929 XATTR=$ac_cv_path_XATTR
18930 if test -n "$XATTR"; then
18931   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
18932 $as_echo "$XATTR" >&6; }
18933 else
18934   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18935 $as_echo "no" >&6; }
18936 fi
18937 
18938 
18939         if test "x$XATTR" = x; then
18940           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18941         fi
18942       else
18943         # Otherwise we believe it is a complete path. Use it as it is.
18944         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
18945 $as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
18946         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
18947 $as_echo_n "checking for XATTR... " >&6; }
18948         if test ! -x "$tool_specified"; then
18949           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18950 $as_echo "not found" >&6; }
18951           as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
18952         fi
18953         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18954 $as_echo "$tool_specified" >&6; }
18955       fi
18956     fi
18957   fi
18958 
18959 
18960 
18961   if test "x$XATTR" = x; then
18962     as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
18963   fi
18964 
18965 
18966 
18967 
18968   # Publish this variable in the help.
18969 
18970 
18971   if test "x$CODESIGN" = x; then
18972     # The variable is not set by user, try to locate tool using the code snippet
18973     for ac_prog in codesign
18974 do
18975   # Extract the first word of "$ac_prog", so it can be a program name with args.
18976 set dummy $ac_prog; ac_word=$2
18977 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18978 $as_echo_n "checking for $ac_word... " >&6; }
18979 if ${ac_cv_path_CODESIGN+:} false; then :
18980   $as_echo_n "(cached) " >&6
18981 else
18982   case $CODESIGN in
18983   [\\/]* | ?:[\\/]*)
18984   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
18985   ;;
18986   *)
18987   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18988 for as_dir in $PATH
18989 do
18990   IFS=$as_save_IFS
18991   test -z "$as_dir" && as_dir=.
18992     for ac_exec_ext in '' $ac_executable_extensions; do
18993   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18994     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
18995     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18996     break 2
18997   fi
18998 done
18999   done
19000 IFS=$as_save_IFS
19001 
19002   ;;
19003 esac
19004 fi
19005 CODESIGN=$ac_cv_path_CODESIGN
19006 if test -n "$CODESIGN"; then
19007   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19008 $as_echo "$CODESIGN" >&6; }
19009 else
19010   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19011 $as_echo "no" >&6; }
19012 fi
19013 
19014 
19015   test -n "$CODESIGN" && break
19016 done
19017 
19018   else
19019     # The variable is set, but is it from the command line or the environment?
19020 
19021     # Try to remove the string !CODESIGN! from our list.
19022     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
19023     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19024       # If it failed, the variable was not from the command line. Ignore it,
19025       # but warn the user (except for BASH, which is always set by the calling BASH).
19026       if test "xCODESIGN" != xBASH; then
19027         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
19028 $as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
19029       fi
19030       # Try to locate tool using the code snippet
19031       for ac_prog in codesign
19032 do
19033   # Extract the first word of "$ac_prog", so it can be a program name with args.
19034 set dummy $ac_prog; ac_word=$2
19035 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19036 $as_echo_n "checking for $ac_word... " >&6; }
19037 if ${ac_cv_path_CODESIGN+:} false; then :
19038   $as_echo_n "(cached) " >&6
19039 else
19040   case $CODESIGN in
19041   [\\/]* | ?:[\\/]*)
19042   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19043   ;;
19044   *)
19045   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19046 for as_dir in $PATH
19047 do
19048   IFS=$as_save_IFS
19049   test -z "$as_dir" && as_dir=.
19050     for ac_exec_ext in '' $ac_executable_extensions; do
19051   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19052     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19053     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19054     break 2
19055   fi
19056 done
19057   done
19058 IFS=$as_save_IFS
19059 
19060   ;;
19061 esac
19062 fi
19063 CODESIGN=$ac_cv_path_CODESIGN
19064 if test -n "$CODESIGN"; then
19065   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19066 $as_echo "$CODESIGN" >&6; }
19067 else
19068   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19069 $as_echo "no" >&6; }
19070 fi
19071 
19072 
19073   test -n "$CODESIGN" && break
19074 done
19075 
19076     else
19077       # If it succeeded, then it was overridden by the user. We will use it
19078       # for the tool.
19079 
19080       # First remove it from the list of overridden variables, so we can test
19081       # for unknown variables in the end.
19082       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19083 
19084       # Check if the provided tool contains a complete path.
19085       tool_specified="$CODESIGN"
19086       tool_basename="${tool_specified##*/}"
19087       if test "x$tool_basename" = "x$tool_specified"; then
19088         # A command without a complete path is provided, search $PATH.
19089         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
19090 $as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
19091         # Extract the first word of "$tool_basename", so it can be a program name with args.
19092 set dummy $tool_basename; ac_word=$2
19093 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19094 $as_echo_n "checking for $ac_word... " >&6; }
19095 if ${ac_cv_path_CODESIGN+:} false; then :
19096   $as_echo_n "(cached) " >&6
19097 else
19098   case $CODESIGN in
19099   [\\/]* | ?:[\\/]*)
19100   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19101   ;;
19102   *)
19103   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19104 for as_dir in $PATH
19105 do
19106   IFS=$as_save_IFS
19107   test -z "$as_dir" && as_dir=.
19108     for ac_exec_ext in '' $ac_executable_extensions; do
19109   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19110     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19111     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19112     break 2
19113   fi
19114 done
19115   done
19116 IFS=$as_save_IFS
19117 
19118   ;;
19119 esac
19120 fi
19121 CODESIGN=$ac_cv_path_CODESIGN
19122 if test -n "$CODESIGN"; then
19123   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19124 $as_echo "$CODESIGN" >&6; }
19125 else
19126   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19127 $as_echo "no" >&6; }
19128 fi
19129 
19130 
19131         if test "x$CODESIGN" = x; then
19132           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19133         fi
19134       else
19135         # Otherwise we believe it is a complete path. Use it as it is.
19136         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
19137 $as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
19138         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
19139 $as_echo_n "checking for CODESIGN... " >&6; }
19140         if test ! -x "$tool_specified"; then
19141           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19142 $as_echo "not found" >&6; }
19143           as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
19144         fi
19145         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19146 $as_echo "$tool_specified" >&6; }
19147       fi
19148     fi
19149   fi
19150 
19151 
19152     if test "x$CODESIGN" != "x"; then
19153       # Verify that the openjdk_codesign certificate is present
19154       { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
19155 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
19156       rm -f codesign-testfile
19157       touch codesign-testfile
19158       codesign -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
19159       rm -f codesign-testfile
19160       if test "x$CODESIGN" = x; then
19161         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19162 $as_echo "no" >&6; }
19163       else
19164         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19165 $as_echo "yes" >&6; }
19166       fi
19167     fi
19168   fi
19169 
19170 
19171 # Check if pkg-config is available.
19172 
19173 
19174 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
19175         if test -n "$ac_tool_prefix"; then
19176   # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
19177 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
19178 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19179 $as_echo_n "checking for $ac_word... " >&6; }
19180 if ${ac_cv_path_PKG_CONFIG+:} false; then :
19181   $as_echo_n "(cached) " >&6
19182 else
19183   case $PKG_CONFIG in
19184   [\\/]* | ?:[\\/]*)
19185   ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
19186   ;;
19187   *)
19188   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19189 for as_dir in $PATH
19190 do
19191   IFS=$as_save_IFS
19192   test -z "$as_dir" && as_dir=.
19193     for ac_exec_ext in '' $ac_executable_extensions; do
19194   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19195     ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
19196     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19197     break 2
19198   fi
19199 done
19200   done
19201 IFS=$as_save_IFS
19202 
19203   ;;
19204 esac
19205 fi
19206 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
19207 if test -n "$PKG_CONFIG"; then
19208   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
19209 $as_echo "$PKG_CONFIG" >&6; }
19210 else
19211   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19212 $as_echo "no" >&6; }
19213 fi
19214 
19215 
19216 fi
19217 if test -z "$ac_cv_path_PKG_CONFIG"; then
19218   ac_pt_PKG_CONFIG=$PKG_CONFIG
19219   # Extract the first word of "pkg-config", so it can be a program name with args.
19220 set dummy pkg-config; ac_word=$2
19221 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19222 $as_echo_n "checking for $ac_word... " >&6; }
19223 if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
19224   $as_echo_n "(cached) " >&6
19225 else
19226   case $ac_pt_PKG_CONFIG in
19227   [\\/]* | ?:[\\/]*)
19228   ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
19229   ;;
19230   *)
19231   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19232 for as_dir in $PATH
19233 do
19234   IFS=$as_save_IFS
19235   test -z "$as_dir" && as_dir=.
19236     for ac_exec_ext in '' $ac_executable_extensions; do
19237   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19238     ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
19239     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19240     break 2
19241   fi
19242 done
19243   done
19244 IFS=$as_save_IFS
19245 
19246   ;;
19247 esac
19248 fi
19249 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
19250 if test -n "$ac_pt_PKG_CONFIG"; then
19251   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
19252 $as_echo "$ac_pt_PKG_CONFIG" >&6; }
19253 else
19254   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19255 $as_echo "no" >&6; }
19256 fi
19257 
19258   if test "x$ac_pt_PKG_CONFIG" = x; then
19259     PKG_CONFIG=""
19260   else
19261     case $cross_compiling:$ac_tool_warned in
19262 yes:)
19263 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
19264 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
19265 ac_tool_warned=yes ;;
19266 esac
19267     PKG_CONFIG=$ac_pt_PKG_CONFIG
19268   fi
19269 else
19270   PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
19271 fi
19272 
19273 fi
19274 if test -n "$PKG_CONFIG"; then
19275         _pkg_min_version=0.9.0
19276         { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
19277 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
19278         if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
19279                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19280 $as_echo "yes" >&6; }
19281         else
19282                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19283 $as_echo "no" >&6; }
19284                 PKG_CONFIG=""
19285         fi
19286 
19287 fi
19288 
19289 # After basic tools have been setup, we can check build os specific details.
19290 
19291   ###############################################################################
19292 
19293   # Note that this is the build platform OS version!
19294 
19295   OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`"
19296   OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`"
19297   OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`"
19298   OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`"
19299 
19300 
19301 
19302 
19303 
19304 # Setup builddeps, for automatic downloading of tools we need.
19305 # This is needed before we can call BDEPS_CHECK_MODULE, which is done in
19306 # boot-jdk setup, but we need to have basic tools setup first.
19307 
19308 
19309 # Check whether --with-builddeps-conf was given.
19310 if test "${with_builddeps_conf+set}" = set; then :
19311   withval=$with_builddeps_conf;
19312 fi
19313 
19314 
19315 
19316 # Check whether --with-builddeps-server was given.
19317 if test "${with_builddeps_server+set}" = set; then :
19318   withval=$with_builddeps_server;
19319 fi
19320 
19321 
19322 
19323 # Check whether --with-builddeps-dir was given.
19324 if test "${with_builddeps_dir+set}" = set; then :
19325   withval=$with_builddeps_dir;
19326 else
19327   with_builddeps_dir=/localhome/builddeps
19328 fi
19329 
19330 
19331 
19332 # Check whether --with-builddeps-group was given.
19333 if test "${with_builddeps_group+set}" = set; then :
19334   withval=$with_builddeps_group;
19335 fi
19336 
19337 
19338 
19339 
19340   if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
19341     if test "x$with_builddeps_conf" != x; then
19342       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for supplied builddeps configuration file" >&5
19343 $as_echo_n "checking for supplied builddeps configuration file... " >&6; }
19344       builddepsfile=$with_builddeps_conf
19345       if test -s $builddepsfile; then
19346         . $builddepsfile
19347         { $as_echo "$as_me:${as_lineno-$LINENO}: result: loaded!" >&5
19348 $as_echo "loaded!" >&6; }
19349       else
19350         as_fn_error $? "The given builddeps conf file $with_builddeps_conf could not be loaded!" "$LINENO" 5
19351       fi
19352     else
19353       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for builddeps.conf files in sources..." >&5
19354 $as_echo_n "checking for builddeps.conf files in sources...... " >&6; }
19355       builddepsfile=`mktemp`
19356       touch $builddepsfile
19357       # Put all found confs into a single file.
19358       find ${SRC_ROOT} -name builddeps.conf -exec cat \{\} \; >> $builddepsfile
19359       # Source the file to acquire the variables
19360       if test -s $builddepsfile; then
19361         . $builddepsfile
19362         { $as_echo "$as_me:${as_lineno-$LINENO}: result: found at least one!" >&5
19363 $as_echo "found at least one!" >&6; }
19364       else
19365         as_fn_error $? "Could not find any builddeps.conf at all!" "$LINENO" 5
19366       fi
19367     fi
19368     # Create build and target names that use _ instead of "-" and ".".
19369     # This is necessary to use them in variable names.
19370     build_var=`echo ${OPENJDK_BUILD_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19371     target_var=`echo ${OPENJDK_TARGET_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19372     # Extract rewrite information for build and target
19373     eval rewritten_build=\${REWRITE_${build_var}}
19374     if test "x$rewritten_build" = x; then
19375       rewritten_build=${OPENJDK_BUILD_AUTOCONF_NAME}
19376       echo Build stays the same $rewritten_build
19377     else
19378       echo Rewriting build for builddeps into $rewritten_build
19379     fi
19380     eval rewritten_target=\${REWRITE_${target_var}}
19381     if test "x$rewritten_target" = x; then
19382       rewritten_target=${OPENJDK_TARGET_AUTOCONF_NAME}
19383       echo Target stays the same $rewritten_target
19384     else
19385       echo Rewriting target for builddeps into $rewritten_target
19386     fi
19387     rewritten_build_var=`echo ${rewritten_build} | tr '-' '_' | tr '.' '_'`
19388     rewritten_target_var=`echo ${rewritten_target} | tr '-' '_' | tr '.' '_'`
19389   fi
19390   for ac_prog in 7z unzip
19391 do
19392   # Extract the first word of "$ac_prog", so it can be a program name with args.
19393 set dummy $ac_prog; ac_word=$2
19394 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19395 $as_echo_n "checking for $ac_word... " >&6; }
19396 if ${ac_cv_prog_BDEPS_UNZIP+:} false; then :
19397   $as_echo_n "(cached) " >&6
19398 else
19399   if test -n "$BDEPS_UNZIP"; then
19400   ac_cv_prog_BDEPS_UNZIP="$BDEPS_UNZIP" # Let the user override the test.
19401 else
19402 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19403 for as_dir in $PATH
19404 do
19405   IFS=$as_save_IFS
19406   test -z "$as_dir" && as_dir=.
19407     for ac_exec_ext in '' $ac_executable_extensions; do
19408   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19409     ac_cv_prog_BDEPS_UNZIP="$ac_prog"
19410     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19411     break 2
19412   fi
19413 done
19414   done
19415 IFS=$as_save_IFS
19416 
19417 fi
19418 fi
19419 BDEPS_UNZIP=$ac_cv_prog_BDEPS_UNZIP
19420 if test -n "$BDEPS_UNZIP"; then
19421   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_UNZIP" >&5
19422 $as_echo "$BDEPS_UNZIP" >&6; }
19423 else
19424   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19425 $as_echo "no" >&6; }
19426 fi
19427 
19428 
19429   test -n "$BDEPS_UNZIP" && break
19430 done
19431 
19432   if test "x$BDEPS_UNZIP" = x7z; then
19433     BDEPS_UNZIP="7z x"
19434   fi
19435 
19436   for ac_prog in wget lftp ftp
19437 do
19438   # Extract the first word of "$ac_prog", so it can be a program name with args.
19439 set dummy $ac_prog; ac_word=$2
19440 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19441 $as_echo_n "checking for $ac_word... " >&6; }
19442 if ${ac_cv_prog_BDEPS_FTP+:} false; then :
19443   $as_echo_n "(cached) " >&6
19444 else
19445   if test -n "$BDEPS_FTP"; then
19446   ac_cv_prog_BDEPS_FTP="$BDEPS_FTP" # Let the user override the test.
19447 else
19448 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19449 for as_dir in $PATH
19450 do
19451   IFS=$as_save_IFS
19452   test -z "$as_dir" && as_dir=.
19453     for ac_exec_ext in '' $ac_executable_extensions; do
19454   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19455     ac_cv_prog_BDEPS_FTP="$ac_prog"
19456     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19457     break 2
19458   fi
19459 done
19460   done
19461 IFS=$as_save_IFS
19462 
19463 fi
19464 fi
19465 BDEPS_FTP=$ac_cv_prog_BDEPS_FTP
19466 if test -n "$BDEPS_FTP"; then
19467   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_FTP" >&5
19468 $as_echo "$BDEPS_FTP" >&6; }
19469 else
19470   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19471 $as_echo "no" >&6; }
19472 fi
19473 
19474 
19475   test -n "$BDEPS_FTP" && break
19476 done
19477 
19478 
19479 
19480 ###############################################################################
19481 #
19482 # Determine OpenJDK variants, options and version numbers.
19483 #
19484 ###############################################################################
19485 
19486 # We need build & target for this.
19487 
19488 
19489   ###############################################################################
19490   #
19491   # Should we build a JDK/JVM with headful support (ie a graphical ui)?
19492   # We always build headless support.
19493   #
19494   { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
19495 $as_echo_n "checking headful support... " >&6; }
19496   # Check whether --enable-headful was given.
19497 if test "${enable_headful+set}" = set; then :
19498   enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
19499 else
19500   SUPPORT_HEADFUL=yes
19501 fi
19502 
19503 
19504   SUPPORT_HEADLESS=yes
19505   BUILD_HEADLESS="BUILD_HEADLESS:=true"
19506 
19507   if test "x$SUPPORT_HEADFUL" = xyes; then
19508     # We are building both headful and headless.
19509     headful_msg="include support for both headful and headless"
19510   fi
19511 
19512   if test "x$SUPPORT_HEADFUL" = xno; then
19513     # Thus we are building headless only.
19514     BUILD_HEADLESS="BUILD_HEADLESS:=true"
19515     headful_msg="headless only"
19516   fi
19517 
19518   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
19519 $as_echo "$headful_msg" >&6; }
19520 
19521 
19522 
19523 
19524 
19525   # Control wether Hotspot runs Queens test after build.
19526   # Check whether --enable-hotspot-test-in-build was given.
19527 if test "${enable_hotspot_test_in_build+set}" = set; then :
19528   enableval=$enable_hotspot_test_in_build;
19529 else
19530   enable_hotspot_test_in_build=no
19531 fi
19532 
19533   if test "x$enable_hotspot_test_in_build" = "xyes"; then
19534     TEST_IN_BUILD=true
19535   else
19536     TEST_IN_BUILD=false
19537   fi
19538 
19539 
19540   ###############################################################################
19541   #
19542   # Choose cacerts source file
19543   #
19544 
19545 # Check whether --with-cacerts-file was given.
19546 if test "${with_cacerts_file+set}" = set; then :
19547   withval=$with_cacerts_file;
19548 fi
19549 
19550   if test "x$with_cacerts_file" != x; then
19551     CACERTS_FILE=$with_cacerts_file
19552   else
19553     CACERTS_FILE=${SRC_ROOT}/jdk/src/share/lib/security/cacerts
19554   fi
19555 
19556 
19557   ###############################################################################
19558   #
19559   # Enable or disable unlimited crypto
19560   #
19561   # Check whether --enable-unlimited-crypto was given.
19562 if test "${enable_unlimited_crypto+set}" = set; then :
19563   enableval=$enable_unlimited_crypto;
19564 else
19565   enable_unlimited_crypto=no
19566 fi
19567 
19568   if test "x$enable_unlimited_crypto" = "xyes"; then
19569     UNLIMITED_CRYPTO=true
19570   else
19571     UNLIMITED_CRYPTO=false
19572   fi
19573 
19574 
19575   ###############################################################################
19576   #
19577   # Enable or disable the elliptic curve crypto implementation
19578   #
19579 
19580 
19581   ###############################################################################
19582   #
19583   # --enable-rmiconnector-iiop
19584   #
19585   # Check whether --enable-rmiconnector-iiop was given.
19586 if test "${enable_rmiconnector_iiop+set}" = set; then :
19587   enableval=$enable_rmiconnector_iiop;
19588 fi
19589 
19590   if test "x$enable_rmiconnector_iiop" = "xyes"; then
19591     RMICONNECTOR_IIOP=true
19592   else
19593     RMICONNECTOR_IIOP=false
19594   fi
19595 
19596 
19597   ###############################################################################
19598   #
19599   # Compress jars
19600   #
19601   COMPRESS_JARS=false
19602 
19603 
19604 
19605 
19606   # Source the version numbers
19607   . $AUTOCONF_DIR/version-numbers
19608 
19609   # Get the settings from parameters
19610 
19611 # Check whether --with-milestone was given.
19612 if test "${with_milestone+set}" = set; then :
19613   withval=$with_milestone;
19614 fi
19615 
19616   if test "x$with_milestone" = xyes; then
19617     as_fn_error $? "Milestone must have a value" "$LINENO" 5
19618   elif test "x$with_milestone" != x; then
19619     MILESTONE="$with_milestone"
19620   fi
19621   if test "x$MILESTONE" = x; then
19622     MILESTONE=internal
19623   fi
19624 
19625 
19626 # Check whether --with-update-version was given.
19627 if test "${with_update_version+set}" = set; then :
19628   withval=$with_update_version;
19629 fi
19630 
19631   if test "x$with_update_version" = xyes; then
19632     as_fn_error $? "Update version must have a value" "$LINENO" 5
19633   elif test "x$with_update_version" != x; then
19634     JDK_UPDATE_VERSION="$with_update_version"
19635     # On macosx 10.7, it's not possible to set --with-update-version=0X due
19636     # to a bug in expr (which reduces it to just X). To work around this, we
19637     # always add a 0 to one digit update versions.
19638     if test "${#JDK_UPDATE_VERSION}" = "1"; then
19639       JDK_UPDATE_VERSION="0${JDK_UPDATE_VERSION}"
19640     fi
19641   fi
19642 
19643 
19644 # Check whether --with-user-release-suffix was given.
19645 if test "${with_user_release_suffix+set}" = set; then :
19646   withval=$with_user_release_suffix;
19647 fi
19648 
19649   if test "x$with_user_release_suffix" = xyes; then
19650     as_fn_error $? "Release suffix must have a value" "$LINENO" 5
19651   elif test "x$with_user_release_suffix" != x; then
19652     USER_RELEASE_SUFFIX="$with_user_release_suffix"
19653   fi
19654 
19655 
19656 # Check whether --with-build-number was given.
19657 if test "${with_build_number+set}" = set; then :
19658   withval=$with_build_number;
19659 fi
19660 
19661   if test "x$with_build_number" = xyes; then
19662     as_fn_error $? "Build number must have a value" "$LINENO" 5
19663   elif test "x$with_build_number" != x; then
19664     JDK_BUILD_NUMBER="$with_build_number"
19665   fi
19666   # Define default USER_RELEASE_SUFFIX if BUILD_NUMBER and USER_RELEASE_SUFFIX are not set
19667   if test "x$JDK_BUILD_NUMBER" = x; then
19668     JDK_BUILD_NUMBER=b00
19669     if test "x$USER_RELEASE_SUFFIX" = x; then
19670       BUILD_DATE=`date '+%Y_%m_%d_%H_%M'`
19671       # Avoid [:alnum:] since it depends on the locale.
19672       CLEAN_USERNAME=`echo "$USER" | $TR -d -c 'abcdefghijklmnopqrstuvqxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'`
19673       USER_RELEASE_SUFFIX=`echo "${CLEAN_USERNAME}_${BUILD_DATE}" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19674     fi
19675   fi
19676 
19677   # Now set the JDK version, milestone, build number etc.
19678 
19679 
19680 
19681 
19682 
19683 
19684 
19685 
19686 
19687 
19688 
19689 
19690 
19691 
19692 
19693   COPYRIGHT_YEAR=`date +'%Y'`
19694 
19695 
19696   if test "x$JDK_UPDATE_VERSION" != x; then
19697     JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}_${JDK_UPDATE_VERSION}"
19698   else
19699     JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}"
19700   fi
19701 
19702 
19703   COOKED_BUILD_NUMBER=`$ECHO $JDK_BUILD_NUMBER | $SED -e 's/^b//' -e 's/^0//'`
19704 
19705 
19706 
19707 ###############################################################################
19708 #
19709 # Setup BootJDK, used to bootstrap the build.
19710 #
19711 ###############################################################################
19712 
19713 
19714   BOOT_JDK_FOUND=no
19715 
19716 # Check whether --with-boot-jdk was given.
19717 if test "${with_boot_jdk+set}" = set; then :
19718   withval=$with_boot_jdk;
19719 fi
19720 
19721 
19722   # We look for the Boot JDK through various means, going from more certain to
19723   # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
19724   # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
19725   # must check if this is indeed valid; otherwise we'll continue looking.
19726 
19727   # Test: Is bootjdk explicitely set by command line arguments?
19728 
19729   if test "x$BOOT_JDK_FOUND" = xno; then
19730     # Now execute the test
19731 
19732   if test "x$with_boot_jdk" != x; then
19733     BOOT_JDK=$with_boot_jdk
19734     BOOT_JDK_FOUND=maybe
19735     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
19736 $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
19737   fi
19738 
19739 
19740     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
19741     if test "x$BOOT_JDK_FOUND" = xmaybe; then
19742       # Do we have a bin/java?
19743       if test ! -x "$BOOT_JDK/bin/java"; then
19744         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
19745 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
19746         BOOT_JDK_FOUND=no
19747       else
19748         # Do we have a bin/javac?
19749         if test ! -x "$BOOT_JDK/bin/javac"; then
19750           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
19751 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
19752           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
19753 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
19754           BOOT_JDK_FOUND=no
19755         else
19756           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
19757           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
19758             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
19759 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
19760             BOOT_JDK_FOUND=no
19761           else
19762             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
19763             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
19764 
19765             # Extra M4 quote needed to protect [] in grep expression.
19766             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
19767             if test "x$FOUND_CORRECT_VERSION" = x; then
19768               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
19769 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
19770               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
19771 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
19772               BOOT_JDK_FOUND=no
19773             else
19774               # We're done! :-)
19775               BOOT_JDK_FOUND=yes
19776 
19777   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19778 
19779   # Input might be given as Windows format, start by converting to
19780   # unix format.
19781   path="$BOOT_JDK"
19782   new_path=`$CYGPATH -u "$path"`
19783 
19784   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
19785   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
19786   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
19787   # "foo.exe" is OK but "foo" is an error.
19788   #
19789   # This test is therefore slightly more accurate than "test -f" to check for file precense.
19790   # It is also a way to make sure we got the proper file name for the real test later on.
19791   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
19792   if test "x$test_shortpath" = x; then
19793     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
19794 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
19795     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
19796   fi
19797 
19798   # Call helper function which possibly converts this using DOS-style short mode.
19799   # If so, the updated path is stored in $new_path.
19800 
19801   input_path="$new_path"
19802   # Check if we need to convert this using DOS-style short mode. If the path
19803   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19804   # take no chances and rewrite it.
19805   # Note: m4 eats our [], so we need to use [ and ] instead.
19806   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
19807   if test "x$has_forbidden_chars" != x; then
19808     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19809     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
19810     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
19811     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
19812       # Going to short mode and back again did indeed matter. Since short mode is
19813       # case insensitive, let's make it lowercase to improve readability.
19814       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19815       # Now convert it back to Unix-stile (cygpath)
19816       input_path=`$CYGPATH -u "$shortmode_path"`
19817       new_path="$input_path"
19818     fi
19819   fi
19820 
19821   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
19822   if test "x$test_cygdrive_prefix" = x; then
19823     # As a simple fix, exclude /usr/bin since it's not a real path.
19824     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
19825       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
19826       # a path prefixed by /cygdrive for fixpath to work.
19827       new_path="$CYGWIN_ROOT_PATH$input_path"
19828     fi
19829   fi
19830 
19831 
19832   if test "x$path" != "x$new_path"; then
19833     BOOT_JDK="$new_path"
19834     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
19835 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
19836   fi
19837 
19838   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19839 
19840   path="$BOOT_JDK"
19841   has_colon=`$ECHO $path | $GREP ^.:`
19842   new_path="$path"
19843   if test "x$has_colon" = x; then
19844     # Not in mixed or Windows style, start by that.
19845     new_path=`cmd //c echo $path`
19846   fi
19847 
19848 
19849   input_path="$new_path"
19850   # Check if we need to convert this using DOS-style short mode. If the path
19851   # contains just simple characters, use it. Otherwise (spaces, weird characters),
19852   # take no chances and rewrite it.
19853   # Note: m4 eats our [], so we need to use [ and ] instead.
19854   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
19855   if test "x$has_forbidden_chars" != x; then
19856     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
19857     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19858   fi
19859 
19860 
19861   windows_path="$new_path"
19862   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
19863     unix_path=`$CYGPATH -u "$windows_path"`
19864     new_path="$unix_path"
19865   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
19866     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
19867     new_path="$unix_path"
19868   fi
19869 
19870   if test "x$path" != "x$new_path"; then
19871     BOOT_JDK="$new_path"
19872     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
19873 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
19874   fi
19875 
19876   # Save the first 10 bytes of this path to the storage, so fixpath can work.
19877   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
19878 
19879   else
19880     # We're on a posix platform. Hooray! :)
19881     path="$BOOT_JDK"
19882     has_space=`$ECHO "$path" | $GREP " "`
19883     if test "x$has_space" != x; then
19884       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
19885 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
19886       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
19887     fi
19888 
19889     # Use eval to expand a potential ~
19890     eval path="$path"
19891     if test ! -f "$path" && test ! -d "$path"; then
19892       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
19893     fi
19894 
19895     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
19896   fi
19897 
19898               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
19899 $as_echo_n "checking for Boot JDK... " >&6; }
19900               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
19901 $as_echo "$BOOT_JDK" >&6; }
19902               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
19903 $as_echo_n "checking Boot JDK version... " >&6; }
19904               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
19905               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
19906 $as_echo "$BOOT_JDK_VERSION" >&6; }
19907             fi # end check jdk version
19908           fi # end check rt.jar
19909         fi # end check javac
19910       fi # end check java
19911     fi # end check boot jdk found
19912   fi
19913 
19914   if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
19915     # Having specified an argument which is incorrect will produce an instant failure;
19916     # we should not go on looking
19917     as_fn_error $? "The path given by --with-boot-jdk does not contain a valid Boot JDK" "$LINENO" 5
19918   fi
19919 
19920   # Test: Is bootjdk available from builddeps?
19921 
19922   if test "x$BOOT_JDK_FOUND" = xno; then
19923     # Now execute the test
19924 
19925 
19926 
19927   if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
19928     # Source the builddeps file again, to make sure it uses the latest variables!
19929     . $builddepsfile
19930     # Look for a target and build machine specific resource!
19931     eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}_TARGET_${rewritten_target_var}}
19932     if test "x$resource" = x; then
19933       # Ok, lets instead look for a target specific resource
19934       eval resource=\${builddep_bootjdk_TARGET_${rewritten_target_var}}
19935     fi
19936     if test "x$resource" = x; then
19937       # Ok, lets instead look for a build specific resource
19938       eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}}
19939     fi
19940     if test "x$resource" = x; then
19941       # Ok, lets instead look for a generic resource
19942       # (The bootjdk comes from M4 and not the shell, thus no need for eval here.)
19943       resource=${builddep_bootjdk}
19944     fi
19945     if test "x$resource" != x; then
19946       { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for bootjdk" >&5
19947 $as_echo "$as_me: Using builddeps $resource for bootjdk" >&6;}
19948       # If the resource in the builddeps.conf file is an existing directory,
19949       # for example /java/linux/cups
19950       if test -d ${resource}; then
19951         depdir=${resource}
19952       else
19953 
19954   # bootjdk is for example mymodule
19955   # $resource is for example libs/general/libmymod_1_2_3.zip
19956   # $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps
19957   # $with_builddeps_dir is for example /localhome/builddeps
19958   # depdir is the name of the variable into which we store the depdir, eg MYMOD
19959   # Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and
19960   # unzip into the directory: /localhome/builddeps/libmymod_1_2_3
19961   filename=`basename $resource`
19962   filebase=`echo $filename | sed 's/\.[^\.]*$//'`
19963   filebase=${filename%%.*}
19964   extension=${filename#*.}
19965   installdir=$with_builddeps_dir/$filebase
19966   if test ! -f $installdir/$filename.unpacked; then
19967     { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&5
19968 $as_echo "$as_me: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&6;}
19969     if test ! -d $installdir; then
19970       mkdir -p $installdir
19971     fi
19972     if test ! -d $installdir; then
19973       as_fn_error $? "Could not create directory $installdir" "$LINENO" 5
19974     fi
19975     tmpfile=`mktemp $installdir/bootjdk.XXXXXXXXX`
19976     touch $tmpfile
19977     if test ! -f $tmpfile; then
19978       as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5
19979     fi
19980 
19981   # $with_builddeps_server/$resource  is the ftp://abuilddeps.server.com/libs/cups.zip
19982   # $tmpfile is the local file name for the downloaded file.
19983   VALID_TOOL=no
19984   if test "x$BDEPS_FTP" = xwget; then
19985     VALID_TOOL=yes
19986     wget -O $tmpfile $with_builddeps_server/$resource
19987   fi
19988   if test "x$BDEPS_FTP" = xlftp; then
19989     VALID_TOOL=yes
19990     lftp -c "get $with_builddeps_server/$resource  -o $tmpfile"
19991   fi
19992   if test "x$BDEPS_FTP" = xftp; then
19993     VALID_TOOL=yes
19994     FTPSERVER=`echo $with_builddeps_server/$resource  | cut -f 3 -d '/'`
19995     FTPPATH=`echo $with_builddeps_server/$resource  | cut -f 4- -d '/'`
19996     FTPUSERPWD=${FTPSERVER%%@*}
19997     if test "x$FTPSERVER" != "x$FTPUSERPWD"; then
19998       FTPUSER=${userpwd%%:*}
19999       FTPPWD=${userpwd#*@}
20000       FTPSERVER=${FTPSERVER#*@}
20001     else
20002       FTPUSER=ftp
20003       FTPPWD=ftp
20004     fi
20005     # the "pass" command does not work on some
20006     # ftp clients (read ftp.exe) but if it works,
20007     # passive mode is better!
20008     ( \
20009         echo "user $FTPUSER $FTPPWD"        ; \
20010         echo "pass"                         ; \
20011         echo "bin"                          ; \
20012         echo "get $FTPPATH $tmpfile"              ; \
20013     ) | ftp -in $FTPSERVER
20014   fi
20015   if test "x$VALID_TOOL" != xyes; then
20016     as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5
20017   fi
20018 
20019     mv $tmpfile $installdir/$filename
20020     if test ! -s $installdir/$filename; then
20021       as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5
20022     fi
20023     case "$extension" in
20024       zip)  echo "Unzipping $installdir/$filename..."
20025         (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked)
20026         ;;
20027       tar.gz) echo "Untaring $installdir/$filename..."
20028         (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
20029         ;;
20030       tgz) echo "Untaring $installdir/$filename..."
20031         (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
20032         ;;
20033       *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5
20034         ;;
20035     esac
20036   fi
20037   if test -f $installdir/$filename.unpacked; then
20038     depdir=$installdir
20039   fi
20040 
20041       fi
20042       # Source the builddeps file again, because in the previous command, the depdir
20043       # was updated to point at the current build dependency install directory.
20044       . $builddepsfile
20045       # Now extract variables from the builddeps.conf files.
20046       theroot=${builddep_bootjdk_ROOT}
20047       thecflags=${builddep_bootjdk_CFLAGS}
20048       thelibs=${builddep_bootjdk_LIBS}
20049       if test "x$depdir" = x; then
20050         as_fn_error $? "Could not download build dependency bootjdk" "$LINENO" 5
20051       fi
20052       BOOT_JDK=$depdir
20053       if test "x$theroot" != x; then
20054         BOOT_JDK="$theroot"
20055       fi
20056       if test "x$thecflags" != x; then
20057         BOOT_JDK_CFLAGS="$thecflags"
20058       fi
20059       if test "x$thelibs" != x; then
20060         BOOT_JDK_LIBS="$thelibs"
20061       fi
20062       BOOT_JDK_FOUND=maybe
20063       else BOOT_JDK_FOUND=no
20064 
20065     fi
20066     else BOOT_JDK_FOUND=no
20067 
20068   fi
20069 
20070 
20071 
20072     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20073     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20074       # Do we have a bin/java?
20075       if test ! -x "$BOOT_JDK/bin/java"; then
20076         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20077 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20078         BOOT_JDK_FOUND=no
20079       else
20080         # Do we have a bin/javac?
20081         if test ! -x "$BOOT_JDK/bin/javac"; then
20082           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20083 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20084           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20085 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20086           BOOT_JDK_FOUND=no
20087         else
20088           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20089           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20090             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20091 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20092             BOOT_JDK_FOUND=no
20093           else
20094             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20095             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20096 
20097             # Extra M4 quote needed to protect [] in grep expression.
20098             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
20099             if test "x$FOUND_CORRECT_VERSION" = x; then
20100               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20101 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20102               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
20103 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
20104               BOOT_JDK_FOUND=no
20105             else
20106               # We're done! :-)
20107               BOOT_JDK_FOUND=yes
20108 
20109   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20110 
20111   # Input might be given as Windows format, start by converting to
20112   # unix format.
20113   path="$BOOT_JDK"
20114   new_path=`$CYGPATH -u "$path"`
20115 
20116   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20117   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20118   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20119   # "foo.exe" is OK but "foo" is an error.
20120   #
20121   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20122   # It is also a way to make sure we got the proper file name for the real test later on.
20123   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20124   if test "x$test_shortpath" = x; then
20125     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20126 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20127     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20128   fi
20129 
20130   # Call helper function which possibly converts this using DOS-style short mode.
20131   # If so, the updated path is stored in $new_path.
20132 
20133   input_path="$new_path"
20134   # Check if we need to convert this using DOS-style short mode. If the path
20135   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20136   # take no chances and rewrite it.
20137   # Note: m4 eats our [], so we need to use [ and ] instead.
20138   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20139   if test "x$has_forbidden_chars" != x; then
20140     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20141     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20142     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20143     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20144       # Going to short mode and back again did indeed matter. Since short mode is
20145       # case insensitive, let's make it lowercase to improve readability.
20146       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20147       # Now convert it back to Unix-stile (cygpath)
20148       input_path=`$CYGPATH -u "$shortmode_path"`
20149       new_path="$input_path"
20150     fi
20151   fi
20152 
20153   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20154   if test "x$test_cygdrive_prefix" = x; then
20155     # As a simple fix, exclude /usr/bin since it's not a real path.
20156     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20157       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20158       # a path prefixed by /cygdrive for fixpath to work.
20159       new_path="$CYGWIN_ROOT_PATH$input_path"
20160     fi
20161   fi
20162 
20163 
20164   if test "x$path" != "x$new_path"; then
20165     BOOT_JDK="$new_path"
20166     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20167 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20168   fi
20169 
20170   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20171 
20172   path="$BOOT_JDK"
20173   has_colon=`$ECHO $path | $GREP ^.:`
20174   new_path="$path"
20175   if test "x$has_colon" = x; then
20176     # Not in mixed or Windows style, start by that.
20177     new_path=`cmd //c echo $path`
20178   fi
20179 
20180 
20181   input_path="$new_path"
20182   # Check if we need to convert this using DOS-style short mode. If the path
20183   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20184   # take no chances and rewrite it.
20185   # Note: m4 eats our [], so we need to use [ and ] instead.
20186   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20187   if test "x$has_forbidden_chars" != x; then
20188     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20189     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20190   fi
20191 
20192 
20193   windows_path="$new_path"
20194   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20195     unix_path=`$CYGPATH -u "$windows_path"`
20196     new_path="$unix_path"
20197   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20198     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20199     new_path="$unix_path"
20200   fi
20201 
20202   if test "x$path" != "x$new_path"; then
20203     BOOT_JDK="$new_path"
20204     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20205 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20206   fi
20207 
20208   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20209   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20210 
20211   else
20212     # We're on a posix platform. Hooray! :)
20213     path="$BOOT_JDK"
20214     has_space=`$ECHO "$path" | $GREP " "`
20215     if test "x$has_space" != x; then
20216       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20217 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20218       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20219     fi
20220 
20221     # Use eval to expand a potential ~
20222     eval path="$path"
20223     if test ! -f "$path" && test ! -d "$path"; then
20224       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20225     fi
20226 
20227     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20228   fi
20229 
20230               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20231 $as_echo_n "checking for Boot JDK... " >&6; }
20232               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20233 $as_echo "$BOOT_JDK" >&6; }
20234               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20235 $as_echo_n "checking Boot JDK version... " >&6; }
20236               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20237               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20238 $as_echo "$BOOT_JDK_VERSION" >&6; }
20239             fi # end check jdk version
20240           fi # end check rt.jar
20241         fi # end check javac
20242       fi # end check java
20243     fi # end check boot jdk found
20244   fi
20245 
20246 
20247   # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
20248 
20249   if test "x$BOOT_JDK_FOUND" = xno; then
20250     # Now execute the test
20251 
20252   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
20253     # First check at user selected default
20254 
20255   if test "x$BOOT_JDK_FOUND" = xno; then
20256     # Now execute the test
20257 
20258   if test -x /usr/libexec/java_home; then
20259     BOOT_JDK=`/usr/libexec/java_home `
20260     BOOT_JDK_FOUND=maybe
20261     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home " >&5
20262 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home " >&6;}
20263   fi
20264 
20265 
20266     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20267     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20268       # Do we have a bin/java?
20269       if test ! -x "$BOOT_JDK/bin/java"; then
20270         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20271 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20272         BOOT_JDK_FOUND=no
20273       else
20274         # Do we have a bin/javac?
20275         if test ! -x "$BOOT_JDK/bin/javac"; then
20276           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20277 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20278           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20279 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20280           BOOT_JDK_FOUND=no
20281         else
20282           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20283           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20284             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20285 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20286             BOOT_JDK_FOUND=no
20287           else
20288             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20289             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20290 
20291             # Extra M4 quote needed to protect [] in grep expression.
20292             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
20293             if test "x$FOUND_CORRECT_VERSION" = x; then
20294               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20295 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20296               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
20297 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
20298               BOOT_JDK_FOUND=no
20299             else
20300               # We're done! :-)
20301               BOOT_JDK_FOUND=yes
20302 
20303   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20304 
20305   # Input might be given as Windows format, start by converting to
20306   # unix format.
20307   path="$BOOT_JDK"
20308   new_path=`$CYGPATH -u "$path"`
20309 
20310   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20311   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20312   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20313   # "foo.exe" is OK but "foo" is an error.
20314   #
20315   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20316   # It is also a way to make sure we got the proper file name for the real test later on.
20317   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20318   if test "x$test_shortpath" = x; then
20319     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20320 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20321     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20322   fi
20323 
20324   # Call helper function which possibly converts this using DOS-style short mode.
20325   # If so, the updated path is stored in $new_path.
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     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20336     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20337     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20338       # Going to short mode and back again did indeed matter. Since short mode is
20339       # case insensitive, let's make it lowercase to improve readability.
20340       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20341       # Now convert it back to Unix-stile (cygpath)
20342       input_path=`$CYGPATH -u "$shortmode_path"`
20343       new_path="$input_path"
20344     fi
20345   fi
20346 
20347   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20348   if test "x$test_cygdrive_prefix" = x; then
20349     # As a simple fix, exclude /usr/bin since it's not a real path.
20350     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20351       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20352       # a path prefixed by /cygdrive for fixpath to work.
20353       new_path="$CYGWIN_ROOT_PATH$input_path"
20354     fi
20355   fi
20356 
20357 
20358   if test "x$path" != "x$new_path"; then
20359     BOOT_JDK="$new_path"
20360     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20361 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20362   fi
20363 
20364   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20365 
20366   path="$BOOT_JDK"
20367   has_colon=`$ECHO $path | $GREP ^.:`
20368   new_path="$path"
20369   if test "x$has_colon" = x; then
20370     # Not in mixed or Windows style, start by that.
20371     new_path=`cmd //c echo $path`
20372   fi
20373 
20374 
20375   input_path="$new_path"
20376   # Check if we need to convert this using DOS-style short mode. If the path
20377   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20378   # take no chances and rewrite it.
20379   # Note: m4 eats our [], so we need to use [ and ] instead.
20380   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20381   if test "x$has_forbidden_chars" != x; then
20382     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20383     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20384   fi
20385 
20386 
20387   windows_path="$new_path"
20388   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20389     unix_path=`$CYGPATH -u "$windows_path"`
20390     new_path="$unix_path"
20391   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20392     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20393     new_path="$unix_path"
20394   fi
20395 
20396   if test "x$path" != "x$new_path"; then
20397     BOOT_JDK="$new_path"
20398     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20399 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20400   fi
20401 
20402   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20403   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20404 
20405   else
20406     # We're on a posix platform. Hooray! :)
20407     path="$BOOT_JDK"
20408     has_space=`$ECHO "$path" | $GREP " "`
20409     if test "x$has_space" != x; then
20410       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20411 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20412       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20413     fi
20414 
20415     # Use eval to expand a potential ~
20416     eval path="$path"
20417     if test ! -f "$path" && test ! -d "$path"; then
20418       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20419     fi
20420 
20421     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20422   fi
20423 
20424               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20425 $as_echo_n "checking for Boot JDK... " >&6; }
20426               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20427 $as_echo "$BOOT_JDK" >&6; }
20428               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20429 $as_echo_n "checking Boot JDK version... " >&6; }
20430               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20431               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20432 $as_echo "$BOOT_JDK_VERSION" >&6; }
20433             fi # end check jdk version
20434           fi # end check rt.jar
20435         fi # end check javac
20436       fi # end check java
20437     fi # end check boot jdk found
20438   fi
20439 
20440     # If that did not work out (e.g. too old), try explicit versions instead
20441 
20442   if test "x$BOOT_JDK_FOUND" = xno; then
20443     # Now execute the test
20444 
20445   if test -x /usr/libexec/java_home; then
20446     BOOT_JDK=`/usr/libexec/java_home -v 1.9`
20447     BOOT_JDK_FOUND=maybe
20448     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&5
20449 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&6;}
20450   fi
20451 
20452 
20453     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20454     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20455       # Do we have a bin/java?
20456       if test ! -x "$BOOT_JDK/bin/java"; then
20457         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20458 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20459         BOOT_JDK_FOUND=no
20460       else
20461         # Do we have a bin/javac?
20462         if test ! -x "$BOOT_JDK/bin/javac"; then
20463           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20464 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20465           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20466 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20467           BOOT_JDK_FOUND=no
20468         else
20469           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20470           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20471             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20472 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20473             BOOT_JDK_FOUND=no
20474           else
20475             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20476             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20477 
20478             # Extra M4 quote needed to protect [] in grep expression.
20479             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
20480             if test "x$FOUND_CORRECT_VERSION" = x; then
20481               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20482 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20483               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
20484 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
20485               BOOT_JDK_FOUND=no
20486             else
20487               # We're done! :-)
20488               BOOT_JDK_FOUND=yes
20489 
20490   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20491 
20492   # Input might be given as Windows format, start by converting to
20493   # unix format.
20494   path="$BOOT_JDK"
20495   new_path=`$CYGPATH -u "$path"`
20496 
20497   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20498   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20499   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20500   # "foo.exe" is OK but "foo" is an error.
20501   #
20502   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20503   # It is also a way to make sure we got the proper file name for the real test later on.
20504   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20505   if test "x$test_shortpath" = x; then
20506     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20507 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20508     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20509   fi
20510 
20511   # Call helper function which possibly converts this using DOS-style short mode.
20512   # If so, the updated path is stored in $new_path.
20513 
20514   input_path="$new_path"
20515   # Check if we need to convert this using DOS-style short mode. If the path
20516   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20517   # take no chances and rewrite it.
20518   # Note: m4 eats our [], so we need to use [ and ] instead.
20519   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20520   if test "x$has_forbidden_chars" != x; then
20521     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20522     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20523     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20524     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20525       # Going to short mode and back again did indeed matter. Since short mode is
20526       # case insensitive, let's make it lowercase to improve readability.
20527       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20528       # Now convert it back to Unix-stile (cygpath)
20529       input_path=`$CYGPATH -u "$shortmode_path"`
20530       new_path="$input_path"
20531     fi
20532   fi
20533 
20534   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20535   if test "x$test_cygdrive_prefix" = x; then
20536     # As a simple fix, exclude /usr/bin since it's not a real path.
20537     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20538       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20539       # a path prefixed by /cygdrive for fixpath to work.
20540       new_path="$CYGWIN_ROOT_PATH$input_path"
20541     fi
20542   fi
20543 
20544 
20545   if test "x$path" != "x$new_path"; then
20546     BOOT_JDK="$new_path"
20547     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20548 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20549   fi
20550 
20551   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20552 
20553   path="$BOOT_JDK"
20554   has_colon=`$ECHO $path | $GREP ^.:`
20555   new_path="$path"
20556   if test "x$has_colon" = x; then
20557     # Not in mixed or Windows style, start by that.
20558     new_path=`cmd //c echo $path`
20559   fi
20560 
20561 
20562   input_path="$new_path"
20563   # Check if we need to convert this using DOS-style short mode. If the path
20564   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20565   # take no chances and rewrite it.
20566   # Note: m4 eats our [], so we need to use [ and ] instead.
20567   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20568   if test "x$has_forbidden_chars" != x; then
20569     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20570     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20571   fi
20572 
20573 
20574   windows_path="$new_path"
20575   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20576     unix_path=`$CYGPATH -u "$windows_path"`
20577     new_path="$unix_path"
20578   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20579     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20580     new_path="$unix_path"
20581   fi
20582 
20583   if test "x$path" != "x$new_path"; then
20584     BOOT_JDK="$new_path"
20585     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20586 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20587   fi
20588 
20589   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20590   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20591 
20592   else
20593     # We're on a posix platform. Hooray! :)
20594     path="$BOOT_JDK"
20595     has_space=`$ECHO "$path" | $GREP " "`
20596     if test "x$has_space" != x; then
20597       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20598 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20599       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20600     fi
20601 
20602     # Use eval to expand a potential ~
20603     eval path="$path"
20604     if test ! -f "$path" && test ! -d "$path"; then
20605       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20606     fi
20607 
20608     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20609   fi
20610 
20611               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20612 $as_echo_n "checking for Boot JDK... " >&6; }
20613               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20614 $as_echo "$BOOT_JDK" >&6; }
20615               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20616 $as_echo_n "checking Boot JDK version... " >&6; }
20617               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20618               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20619 $as_echo "$BOOT_JDK_VERSION" >&6; }
20620             fi # end check jdk version
20621           fi # end check rt.jar
20622         fi # end check javac
20623       fi # end check java
20624     fi # end check boot jdk found
20625   fi
20626 
20627 
20628   if test "x$BOOT_JDK_FOUND" = xno; then
20629     # Now execute the test
20630 
20631   if test -x /usr/libexec/java_home; then
20632     BOOT_JDK=`/usr/libexec/java_home -v 1.8`
20633     BOOT_JDK_FOUND=maybe
20634     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&5
20635 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&6;}
20636   fi
20637 
20638 
20639     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20640     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20641       # Do we have a bin/java?
20642       if test ! -x "$BOOT_JDK/bin/java"; then
20643         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20644 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20645         BOOT_JDK_FOUND=no
20646       else
20647         # Do we have a bin/javac?
20648         if test ! -x "$BOOT_JDK/bin/javac"; then
20649           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20650 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20651           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20652 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20653           BOOT_JDK_FOUND=no
20654         else
20655           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20656           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20657             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20658 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20659             BOOT_JDK_FOUND=no
20660           else
20661             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20662             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20663 
20664             # Extra M4 quote needed to protect [] in grep expression.
20665             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
20666             if test "x$FOUND_CORRECT_VERSION" = x; then
20667               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20668 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20669               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
20670 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
20671               BOOT_JDK_FOUND=no
20672             else
20673               # We're done! :-)
20674               BOOT_JDK_FOUND=yes
20675 
20676   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20677 
20678   # Input might be given as Windows format, start by converting to
20679   # unix format.
20680   path="$BOOT_JDK"
20681   new_path=`$CYGPATH -u "$path"`
20682 
20683   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20684   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20685   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20686   # "foo.exe" is OK but "foo" is an error.
20687   #
20688   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20689   # It is also a way to make sure we got the proper file name for the real test later on.
20690   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20691   if test "x$test_shortpath" = x; then
20692     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20693 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20694     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20695   fi
20696 
20697   # Call helper function which possibly converts this using DOS-style short mode.
20698   # If so, the updated path is stored in $new_path.
20699 
20700   input_path="$new_path"
20701   # Check if we need to convert this using DOS-style short mode. If the path
20702   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20703   # take no chances and rewrite it.
20704   # Note: m4 eats our [], so we need to use [ and ] instead.
20705   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20706   if test "x$has_forbidden_chars" != x; then
20707     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20708     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20709     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20710     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20711       # Going to short mode and back again did indeed matter. Since short mode is
20712       # case insensitive, let's make it lowercase to improve readability.
20713       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20714       # Now convert it back to Unix-stile (cygpath)
20715       input_path=`$CYGPATH -u "$shortmode_path"`
20716       new_path="$input_path"
20717     fi
20718   fi
20719 
20720   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20721   if test "x$test_cygdrive_prefix" = x; then
20722     # As a simple fix, exclude /usr/bin since it's not a real path.
20723     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20724       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20725       # a path prefixed by /cygdrive for fixpath to work.
20726       new_path="$CYGWIN_ROOT_PATH$input_path"
20727     fi
20728   fi
20729 
20730 
20731   if test "x$path" != "x$new_path"; then
20732     BOOT_JDK="$new_path"
20733     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20734 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20735   fi
20736 
20737   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20738 
20739   path="$BOOT_JDK"
20740   has_colon=`$ECHO $path | $GREP ^.:`
20741   new_path="$path"
20742   if test "x$has_colon" = x; then
20743     # Not in mixed or Windows style, start by that.
20744     new_path=`cmd //c echo $path`
20745   fi
20746 
20747 
20748   input_path="$new_path"
20749   # Check if we need to convert this using DOS-style short mode. If the path
20750   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20751   # take no chances and rewrite it.
20752   # Note: m4 eats our [], so we need to use [ and ] instead.
20753   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20754   if test "x$has_forbidden_chars" != x; then
20755     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20756     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20757   fi
20758 
20759 
20760   windows_path="$new_path"
20761   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20762     unix_path=`$CYGPATH -u "$windows_path"`
20763     new_path="$unix_path"
20764   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20765     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20766     new_path="$unix_path"
20767   fi
20768 
20769   if test "x$path" != "x$new_path"; then
20770     BOOT_JDK="$new_path"
20771     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20772 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20773   fi
20774 
20775   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20776   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20777 
20778   else
20779     # We're on a posix platform. Hooray! :)
20780     path="$BOOT_JDK"
20781     has_space=`$ECHO "$path" | $GREP " "`
20782     if test "x$has_space" != x; then
20783       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20784 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20785       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20786     fi
20787 
20788     # Use eval to expand a potential ~
20789     eval path="$path"
20790     if test ! -f "$path" && test ! -d "$path"; then
20791       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20792     fi
20793 
20794     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20795   fi
20796 
20797               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20798 $as_echo_n "checking for Boot JDK... " >&6; }
20799               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20800 $as_echo "$BOOT_JDK" >&6; }
20801               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20802 $as_echo_n "checking Boot JDK version... " >&6; }
20803               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20804               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20805 $as_echo "$BOOT_JDK_VERSION" >&6; }
20806             fi # end check jdk version
20807           fi # end check rt.jar
20808         fi # end check javac
20809       fi # end check java
20810     fi # end check boot jdk found
20811   fi
20812 
20813 
20814   if test "x$BOOT_JDK_FOUND" = xno; then
20815     # Now execute the test
20816 
20817   if test -x /usr/libexec/java_home; then
20818     BOOT_JDK=`/usr/libexec/java_home -v 1.7`
20819     BOOT_JDK_FOUND=maybe
20820     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&5
20821 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&6;}
20822   fi
20823 
20824 
20825     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20826     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20827       # Do we have a bin/java?
20828       if test ! -x "$BOOT_JDK/bin/java"; then
20829         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20830 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20831         BOOT_JDK_FOUND=no
20832       else
20833         # Do we have a bin/javac?
20834         if test ! -x "$BOOT_JDK/bin/javac"; then
20835           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20836 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20837           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20838 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20839           BOOT_JDK_FOUND=no
20840         else
20841           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20842           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20843             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20844 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20845             BOOT_JDK_FOUND=no
20846           else
20847             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20848             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20849 
20850             # Extra M4 quote needed to protect [] in grep expression.
20851             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
20852             if test "x$FOUND_CORRECT_VERSION" = x; then
20853               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20854 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20855               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
20856 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
20857               BOOT_JDK_FOUND=no
20858             else
20859               # We're done! :-)
20860               BOOT_JDK_FOUND=yes
20861 
20862   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20863 
20864   # Input might be given as Windows format, start by converting to
20865   # unix format.
20866   path="$BOOT_JDK"
20867   new_path=`$CYGPATH -u "$path"`
20868 
20869   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20870   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20871   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20872   # "foo.exe" is OK but "foo" is an error.
20873   #
20874   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20875   # It is also a way to make sure we got the proper file name for the real test later on.
20876   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20877   if test "x$test_shortpath" = x; then
20878     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20879 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20880     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20881   fi
20882 
20883   # Call helper function which possibly converts this using DOS-style short mode.
20884   # If so, the updated path is stored in $new_path.
20885 
20886   input_path="$new_path"
20887   # Check if we need to convert this using DOS-style short mode. If the path
20888   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20889   # take no chances and rewrite it.
20890   # Note: m4 eats our [], so we need to use [ and ] instead.
20891   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20892   if test "x$has_forbidden_chars" != x; then
20893     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20894     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20895     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20896     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20897       # Going to short mode and back again did indeed matter. Since short mode is
20898       # case insensitive, let's make it lowercase to improve readability.
20899       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20900       # Now convert it back to Unix-stile (cygpath)
20901       input_path=`$CYGPATH -u "$shortmode_path"`
20902       new_path="$input_path"
20903     fi
20904   fi
20905 
20906   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20907   if test "x$test_cygdrive_prefix" = x; then
20908     # As a simple fix, exclude /usr/bin since it's not a real path.
20909     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20910       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20911       # a path prefixed by /cygdrive for fixpath to work.
20912       new_path="$CYGWIN_ROOT_PATH$input_path"
20913     fi
20914   fi
20915 
20916 
20917   if test "x$path" != "x$new_path"; then
20918     BOOT_JDK="$new_path"
20919     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20920 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20921   fi
20922 
20923   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20924 
20925   path="$BOOT_JDK"
20926   has_colon=`$ECHO $path | $GREP ^.:`
20927   new_path="$path"
20928   if test "x$has_colon" = x; then
20929     # Not in mixed or Windows style, start by that.
20930     new_path=`cmd //c echo $path`
20931   fi
20932 
20933 
20934   input_path="$new_path"
20935   # Check if we need to convert this using DOS-style short mode. If the path
20936   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20937   # take no chances and rewrite it.
20938   # Note: m4 eats our [], so we need to use [ and ] instead.
20939   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20940   if test "x$has_forbidden_chars" != x; then
20941     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20942     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20943   fi
20944 
20945 
20946   windows_path="$new_path"
20947   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20948     unix_path=`$CYGPATH -u "$windows_path"`
20949     new_path="$unix_path"
20950   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20951     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20952     new_path="$unix_path"
20953   fi
20954 
20955   if test "x$path" != "x$new_path"; then
20956     BOOT_JDK="$new_path"
20957     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20958 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20959   fi
20960 
20961   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20962   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20963 
20964   else
20965     # We're on a posix platform. Hooray! :)
20966     path="$BOOT_JDK"
20967     has_space=`$ECHO "$path" | $GREP " "`
20968     if test "x$has_space" != x; then
20969       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20970 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20971       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20972     fi
20973 
20974     # Use eval to expand a potential ~
20975     eval path="$path"
20976     if test ! -f "$path" && test ! -d "$path"; then
20977       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20978     fi
20979 
20980     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20981   fi
20982 
20983               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20984 $as_echo_n "checking for Boot JDK... " >&6; }
20985               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20986 $as_echo "$BOOT_JDK" >&6; }
20987               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20988 $as_echo_n "checking Boot JDK version... " >&6; }
20989               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20990               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20991 $as_echo "$BOOT_JDK_VERSION" >&6; }
20992             fi # end check jdk version
20993           fi # end check rt.jar
20994         fi # end check javac
20995       fi # end check java
20996     fi # end check boot jdk found
20997   fi
20998 
20999   fi
21000 
21001 
21002     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21003     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21004       # Do we have a bin/java?
21005       if test ! -x "$BOOT_JDK/bin/java"; then
21006         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21007 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21008         BOOT_JDK_FOUND=no
21009       else
21010         # Do we have a bin/javac?
21011         if test ! -x "$BOOT_JDK/bin/javac"; then
21012           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21013 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21014           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21015 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21016           BOOT_JDK_FOUND=no
21017         else
21018           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
21019           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
21020             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
21021 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
21022             BOOT_JDK_FOUND=no
21023           else
21024             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21025             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21026 
21027             # Extra M4 quote needed to protect [] in grep expression.
21028             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
21029             if test "x$FOUND_CORRECT_VERSION" = x; then
21030               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21031 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21032               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
21033 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
21034               BOOT_JDK_FOUND=no
21035             else
21036               # We're done! :-)
21037               BOOT_JDK_FOUND=yes
21038 
21039   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21040 
21041   # Input might be given as Windows format, start by converting to
21042   # unix format.
21043   path="$BOOT_JDK"
21044   new_path=`$CYGPATH -u "$path"`
21045 
21046   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21047   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21048   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21049   # "foo.exe" is OK but "foo" is an error.
21050   #
21051   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21052   # It is also a way to make sure we got the proper file name for the real test later on.
21053   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21054   if test "x$test_shortpath" = x; then
21055     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21056 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21057     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21058   fi
21059 
21060   # Call helper function which possibly converts this using DOS-style short mode.
21061   # If so, the updated path is stored in $new_path.
21062 
21063   input_path="$new_path"
21064   # Check if we need to convert this using DOS-style short mode. If the path
21065   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21066   # take no chances and rewrite it.
21067   # Note: m4 eats our [], so we need to use [ and ] instead.
21068   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21069   if test "x$has_forbidden_chars" != x; then
21070     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21071     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21072     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21073     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21074       # Going to short mode and back again did indeed matter. Since short mode is
21075       # case insensitive, let's make it lowercase to improve readability.
21076       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21077       # Now convert it back to Unix-stile (cygpath)
21078       input_path=`$CYGPATH -u "$shortmode_path"`
21079       new_path="$input_path"
21080     fi
21081   fi
21082 
21083   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21084   if test "x$test_cygdrive_prefix" = x; then
21085     # As a simple fix, exclude /usr/bin since it's not a real path.
21086     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21087       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21088       # a path prefixed by /cygdrive for fixpath to work.
21089       new_path="$CYGWIN_ROOT_PATH$input_path"
21090     fi
21091   fi
21092 
21093 
21094   if test "x$path" != "x$new_path"; then
21095     BOOT_JDK="$new_path"
21096     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21097 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21098   fi
21099 
21100   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21101 
21102   path="$BOOT_JDK"
21103   has_colon=`$ECHO $path | $GREP ^.:`
21104   new_path="$path"
21105   if test "x$has_colon" = x; then
21106     # Not in mixed or Windows style, start by that.
21107     new_path=`cmd //c echo $path`
21108   fi
21109 
21110 
21111   input_path="$new_path"
21112   # Check if we need to convert this using DOS-style short mode. If the path
21113   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21114   # take no chances and rewrite it.
21115   # Note: m4 eats our [], so we need to use [ and ] instead.
21116   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21117   if test "x$has_forbidden_chars" != x; then
21118     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21119     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21120   fi
21121 
21122 
21123   windows_path="$new_path"
21124   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21125     unix_path=`$CYGPATH -u "$windows_path"`
21126     new_path="$unix_path"
21127   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21128     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21129     new_path="$unix_path"
21130   fi
21131 
21132   if test "x$path" != "x$new_path"; then
21133     BOOT_JDK="$new_path"
21134     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21135 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21136   fi
21137 
21138   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21139   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21140 
21141   else
21142     # We're on a posix platform. Hooray! :)
21143     path="$BOOT_JDK"
21144     has_space=`$ECHO "$path" | $GREP " "`
21145     if test "x$has_space" != x; then
21146       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21147 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21148       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21149     fi
21150 
21151     # Use eval to expand a potential ~
21152     eval path="$path"
21153     if test ! -f "$path" && test ! -d "$path"; then
21154       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21155     fi
21156 
21157     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21158   fi
21159 
21160               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21161 $as_echo_n "checking for Boot JDK... " >&6; }
21162               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21163 $as_echo "$BOOT_JDK" >&6; }
21164               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21165 $as_echo_n "checking Boot JDK version... " >&6; }
21166               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21167               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21168 $as_echo "$BOOT_JDK_VERSION" >&6; }
21169             fi # end check jdk version
21170           fi # end check rt.jar
21171         fi # end check javac
21172       fi # end check java
21173     fi # end check boot jdk found
21174   fi
21175 
21176 
21177   # Test: Is $JAVA_HOME set?
21178 
21179   if test "x$BOOT_JDK_FOUND" = xno; then
21180     # Now execute the test
21181 
21182   if test "x$JAVA_HOME" != x; then
21183     JAVA_HOME_PROCESSED="$JAVA_HOME"
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="$JAVA_HOME_PROCESSED"
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 JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
21202 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
21203     as_fn_error $? "Cannot locate the the path of JAVA_HOME_PROCESSED" "$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     JAVA_HOME_PROCESSED="$new_path"
21242     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
21243 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
21244   fi
21245 
21246   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21247 
21248   path="$JAVA_HOME_PROCESSED"
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     JAVA_HOME_PROCESSED="$new_path"
21280     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
21281 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED 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="$JAVA_HOME_PROCESSED"
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 JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
21293 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, 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 JAVA_HOME_PROCESSED, which resolves as \"$path\", is not found." "$LINENO" 5
21301     fi
21302 
21303     JAVA_HOME_PROCESSED="`cd "$path"; $THEPWDCMD -L`"
21304   fi
21305 
21306     if test ! -d "$JAVA_HOME_PROCESSED"; then
21307       { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
21308 $as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
21309     else
21310       # Aha, the user has set a JAVA_HOME
21311       # let us use that as the Boot JDK.
21312       BOOT_JDK="$JAVA_HOME_PROCESSED"
21313       BOOT_JDK_FOUND=maybe
21314       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using JAVA_HOME" >&5
21315 $as_echo "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
21316     fi
21317   fi
21318 
21319 
21320     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21321     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21322       # Do we have a bin/java?
21323       if test ! -x "$BOOT_JDK/bin/java"; then
21324         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21325 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21326         BOOT_JDK_FOUND=no
21327       else
21328         # Do we have a bin/javac?
21329         if test ! -x "$BOOT_JDK/bin/javac"; then
21330           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21331 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21332           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21333 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21334           BOOT_JDK_FOUND=no
21335         else
21336           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
21337           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
21338             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
21339 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
21340             BOOT_JDK_FOUND=no
21341           else
21342             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21343             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21344 
21345             # Extra M4 quote needed to protect [] in grep expression.
21346             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
21347             if test "x$FOUND_CORRECT_VERSION" = x; then
21348               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21349 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21350               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
21351 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
21352               BOOT_JDK_FOUND=no
21353             else
21354               # We're done! :-)
21355               BOOT_JDK_FOUND=yes
21356 
21357   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21358 
21359   # Input might be given as Windows format, start by converting to
21360   # unix format.
21361   path="$BOOT_JDK"
21362   new_path=`$CYGPATH -u "$path"`
21363 
21364   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21365   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21366   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21367   # "foo.exe" is OK but "foo" is an error.
21368   #
21369   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21370   # It is also a way to make sure we got the proper file name for the real test later on.
21371   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21372   if test "x$test_shortpath" = x; then
21373     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21374 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21375     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21376   fi
21377 
21378   # Call helper function which possibly converts this using DOS-style short mode.
21379   # If so, the updated path is stored in $new_path.
21380 
21381   input_path="$new_path"
21382   # Check if we need to convert this using DOS-style short mode. If the path
21383   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21384   # take no chances and rewrite it.
21385   # Note: m4 eats our [], so we need to use [ and ] instead.
21386   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21387   if test "x$has_forbidden_chars" != x; then
21388     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21389     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21390     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21391     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21392       # Going to short mode and back again did indeed matter. Since short mode is
21393       # case insensitive, let's make it lowercase to improve readability.
21394       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21395       # Now convert it back to Unix-stile (cygpath)
21396       input_path=`$CYGPATH -u "$shortmode_path"`
21397       new_path="$input_path"
21398     fi
21399   fi
21400 
21401   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21402   if test "x$test_cygdrive_prefix" = x; then
21403     # As a simple fix, exclude /usr/bin since it's not a real path.
21404     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21405       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21406       # a path prefixed by /cygdrive for fixpath to work.
21407       new_path="$CYGWIN_ROOT_PATH$input_path"
21408     fi
21409   fi
21410 
21411 
21412   if test "x$path" != "x$new_path"; then
21413     BOOT_JDK="$new_path"
21414     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21415 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21416   fi
21417 
21418   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21419 
21420   path="$BOOT_JDK"
21421   has_colon=`$ECHO $path | $GREP ^.:`
21422   new_path="$path"
21423   if test "x$has_colon" = x; then
21424     # Not in mixed or Windows style, start by that.
21425     new_path=`cmd //c echo $path`
21426   fi
21427 
21428 
21429   input_path="$new_path"
21430   # Check if we need to convert this using DOS-style short mode. If the path
21431   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21432   # take no chances and rewrite it.
21433   # Note: m4 eats our [], so we need to use [ and ] instead.
21434   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21435   if test "x$has_forbidden_chars" != x; then
21436     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21437     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21438   fi
21439 
21440 
21441   windows_path="$new_path"
21442   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21443     unix_path=`$CYGPATH -u "$windows_path"`
21444     new_path="$unix_path"
21445   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21446     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21447     new_path="$unix_path"
21448   fi
21449 
21450   if test "x$path" != "x$new_path"; then
21451     BOOT_JDK="$new_path"
21452     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21453 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21454   fi
21455 
21456   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21457   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21458 
21459   else
21460     # We're on a posix platform. Hooray! :)
21461     path="$BOOT_JDK"
21462     has_space=`$ECHO "$path" | $GREP " "`
21463     if test "x$has_space" != x; then
21464       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21465 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21466       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21467     fi
21468 
21469     # Use eval to expand a potential ~
21470     eval path="$path"
21471     if test ! -f "$path" && test ! -d "$path"; then
21472       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21473     fi
21474 
21475     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21476   fi
21477 
21478               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21479 $as_echo_n "checking for Boot JDK... " >&6; }
21480               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21481 $as_echo "$BOOT_JDK" >&6; }
21482               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21483 $as_echo_n "checking Boot JDK version... " >&6; }
21484               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21485               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21486 $as_echo "$BOOT_JDK_VERSION" >&6; }
21487             fi # end check jdk version
21488           fi # end check rt.jar
21489         fi # end check javac
21490       fi # end check java
21491     fi # end check boot jdk found
21492   fi
21493 
21494 
21495   # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
21496 
21497   if test "x$BOOT_JDK_FOUND" = xno; then
21498     # Now execute the test
21499 
21500   # Extract the first word of "javac", so it can be a program name with args.
21501 set dummy javac; ac_word=$2
21502 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21503 $as_echo_n "checking for $ac_word... " >&6; }
21504 if ${ac_cv_path_JAVAC_CHECK+:} false; then :
21505   $as_echo_n "(cached) " >&6
21506 else
21507   case $JAVAC_CHECK in
21508   [\\/]* | ?:[\\/]*)
21509   ac_cv_path_JAVAC_CHECK="$JAVAC_CHECK" # Let the user override the test with a path.
21510   ;;
21511   *)
21512   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21513 for as_dir in $PATH
21514 do
21515   IFS=$as_save_IFS
21516   test -z "$as_dir" && as_dir=.
21517     for ac_exec_ext in '' $ac_executable_extensions; do
21518   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21519     ac_cv_path_JAVAC_CHECK="$as_dir/$ac_word$ac_exec_ext"
21520     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21521     break 2
21522   fi
21523 done
21524   done
21525 IFS=$as_save_IFS
21526 
21527   ;;
21528 esac
21529 fi
21530 JAVAC_CHECK=$ac_cv_path_JAVAC_CHECK
21531 if test -n "$JAVAC_CHECK"; then
21532   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5
21533 $as_echo "$JAVAC_CHECK" >&6; }
21534 else
21535   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21536 $as_echo "no" >&6; }
21537 fi
21538 
21539 
21540   # Extract the first word of "java", so it can be a program name with args.
21541 set dummy java; ac_word=$2
21542 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21543 $as_echo_n "checking for $ac_word... " >&6; }
21544 if ${ac_cv_path_JAVA_CHECK+:} false; then :
21545   $as_echo_n "(cached) " >&6
21546 else
21547   case $JAVA_CHECK in
21548   [\\/]* | ?:[\\/]*)
21549   ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path.
21550   ;;
21551   *)
21552   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21553 for as_dir in $PATH
21554 do
21555   IFS=$as_save_IFS
21556   test -z "$as_dir" && as_dir=.
21557     for ac_exec_ext in '' $ac_executable_extensions; do
21558   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21559     ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext"
21560     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21561     break 2
21562   fi
21563 done
21564   done
21565 IFS=$as_save_IFS
21566 
21567   ;;
21568 esac
21569 fi
21570 JAVA_CHECK=$ac_cv_path_JAVA_CHECK
21571 if test -n "$JAVA_CHECK"; then
21572   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5
21573 $as_echo "$JAVA_CHECK" >&6; }
21574 else
21575   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21576 $as_echo "no" >&6; }
21577 fi
21578 
21579 
21580   BINARY="$JAVAC_CHECK"
21581   if test "x$JAVAC_CHECK" = x; then
21582     BINARY="$JAVA_CHECK"
21583   fi
21584   if test "x$BINARY" != x; then
21585     # So there is a java(c) binary, it might be part of a JDK.
21586     # Lets find the JDK/JRE directory by following symbolic links.
21587     # Linux/GNU systems often have links from /usr/bin/java to
21588     # /etc/alternatives/java to the real JDK binary.
21589 
21590   if test "x$OPENJDK_BUILD_OS" != xwindows; then
21591     # Follow a chain of symbolic links. Use readlink
21592     # where it exists, else fall back to horribly
21593     # complicated shell code.
21594     if test "x$READLINK_TESTED" != yes; then
21595       # On MacOSX there is a readlink tool with a different
21596       # purpose than the GNU readlink tool. Check the found readlink.
21597       ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
21598       if test "x$ISGNU" = x; then
21599         # A readlink that we do not know how to use.
21600         # Are there other non-GNU readlinks out there?
21601         READLINK_TESTED=yes
21602         READLINK=
21603       fi
21604     fi
21605 
21606     if test "x$READLINK" != x; then
21607       BINARY=`$READLINK -f $BINARY`
21608     else
21609       # Save the current directory for restoring afterwards
21610       STARTDIR=$PWD
21611       COUNTER=0
21612       sym_link_dir=`$DIRNAME $BINARY`
21613       sym_link_file=`$BASENAME $BINARY`
21614       cd $sym_link_dir
21615       # Use -P flag to resolve symlinks in directories.
21616       cd `$THEPWDCMD -P`
21617       sym_link_dir=`$THEPWDCMD -P`
21618       # Resolve file symlinks
21619       while test $COUNTER -lt 20; do
21620         ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
21621         if test "x$ISLINK" == x; then
21622           # This is not a symbolic link! We are done!
21623           break
21624         fi
21625         # Again resolve directory symlinks since the target of the just found
21626         # link could be in a different directory
21627         cd `$DIRNAME $ISLINK`
21628         sym_link_dir=`$THEPWDCMD -P`
21629         sym_link_file=`$BASENAME $ISLINK`
21630         let COUNTER=COUNTER+1
21631       done
21632       cd $STARTDIR
21633       BINARY=$sym_link_dir/$sym_link_file
21634     fi
21635   fi
21636 
21637     BOOT_JDK=`dirname "$BINARY"`
21638     BOOT_JDK=`cd "$BOOT_JDK/.."; pwd`
21639     if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then
21640       # Looks like we found ourselves an JDK
21641       BOOT_JDK_FOUND=maybe
21642       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using java(c) in PATH" >&5
21643 $as_echo "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
21644     fi
21645   fi
21646 
21647 
21648     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21649     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21650       # Do we have a bin/java?
21651       if test ! -x "$BOOT_JDK/bin/java"; then
21652         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21653 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21654         BOOT_JDK_FOUND=no
21655       else
21656         # Do we have a bin/javac?
21657         if test ! -x "$BOOT_JDK/bin/javac"; then
21658           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21659 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21660           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21661 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21662           BOOT_JDK_FOUND=no
21663         else
21664           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
21665           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
21666             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
21667 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
21668             BOOT_JDK_FOUND=no
21669           else
21670             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21671             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21672 
21673             # Extra M4 quote needed to protect [] in grep expression.
21674             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
21675             if test "x$FOUND_CORRECT_VERSION" = x; then
21676               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21677 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21678               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
21679 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
21680               BOOT_JDK_FOUND=no
21681             else
21682               # We're done! :-)
21683               BOOT_JDK_FOUND=yes
21684 
21685   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21686 
21687   # Input might be given as Windows format, start by converting to
21688   # unix format.
21689   path="$BOOT_JDK"
21690   new_path=`$CYGPATH -u "$path"`
21691 
21692   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21693   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21694   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21695   # "foo.exe" is OK but "foo" is an error.
21696   #
21697   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21698   # It is also a way to make sure we got the proper file name for the real test later on.
21699   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21700   if test "x$test_shortpath" = x; then
21701     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21702 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21703     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21704   fi
21705 
21706   # Call helper function which possibly converts this using DOS-style short mode.
21707   # If so, the updated path is stored in $new_path.
21708 
21709   input_path="$new_path"
21710   # Check if we need to convert this using DOS-style short mode. If the path
21711   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21712   # take no chances and rewrite it.
21713   # Note: m4 eats our [], so we need to use [ and ] instead.
21714   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21715   if test "x$has_forbidden_chars" != x; then
21716     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21717     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21718     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21719     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21720       # Going to short mode and back again did indeed matter. Since short mode is
21721       # case insensitive, let's make it lowercase to improve readability.
21722       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21723       # Now convert it back to Unix-stile (cygpath)
21724       input_path=`$CYGPATH -u "$shortmode_path"`
21725       new_path="$input_path"
21726     fi
21727   fi
21728 
21729   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21730   if test "x$test_cygdrive_prefix" = x; then
21731     # As a simple fix, exclude /usr/bin since it's not a real path.
21732     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21733       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21734       # a path prefixed by /cygdrive for fixpath to work.
21735       new_path="$CYGWIN_ROOT_PATH$input_path"
21736     fi
21737   fi
21738 
21739 
21740   if test "x$path" != "x$new_path"; then
21741     BOOT_JDK="$new_path"
21742     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21743 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21744   fi
21745 
21746   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21747 
21748   path="$BOOT_JDK"
21749   has_colon=`$ECHO $path | $GREP ^.:`
21750   new_path="$path"
21751   if test "x$has_colon" = x; then
21752     # Not in mixed or Windows style, start by that.
21753     new_path=`cmd //c echo $path`
21754   fi
21755 
21756 
21757   input_path="$new_path"
21758   # Check if we need to convert this using DOS-style short mode. If the path
21759   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21760   # take no chances and rewrite it.
21761   # Note: m4 eats our [], so we need to use [ and ] instead.
21762   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21763   if test "x$has_forbidden_chars" != x; then
21764     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21765     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21766   fi
21767 
21768 
21769   windows_path="$new_path"
21770   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21771     unix_path=`$CYGPATH -u "$windows_path"`
21772     new_path="$unix_path"
21773   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21774     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21775     new_path="$unix_path"
21776   fi
21777 
21778   if test "x$path" != "x$new_path"; then
21779     BOOT_JDK="$new_path"
21780     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21781 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21782   fi
21783 
21784   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21785   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21786 
21787   else
21788     # We're on a posix platform. Hooray! :)
21789     path="$BOOT_JDK"
21790     has_space=`$ECHO "$path" | $GREP " "`
21791     if test "x$has_space" != x; then
21792       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21793 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21794       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21795     fi
21796 
21797     # Use eval to expand a potential ~
21798     eval path="$path"
21799     if test ! -f "$path" && test ! -d "$path"; then
21800       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21801     fi
21802 
21803     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21804   fi
21805 
21806               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21807 $as_echo_n "checking for Boot JDK... " >&6; }
21808               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21809 $as_echo "$BOOT_JDK" >&6; }
21810               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21811 $as_echo_n "checking Boot JDK version... " >&6; }
21812               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21813               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21814 $as_echo "$BOOT_JDK_VERSION" >&6; }
21815             fi # end check jdk version
21816           fi # end check rt.jar
21817         fi # end check javac
21818       fi # end check java
21819     fi # end check boot jdk found
21820   fi
21821 
21822 
21823   # Test: Is there a JDK installed in default, well-known locations?
21824 
21825   if test "x$BOOT_JDK_FOUND" = xno; then
21826     # Now execute the test
21827 
21828   if test "x$OPENJDK_TARGET_OS" = xwindows; then
21829 
21830   if test "x$BOOT_JDK_FOUND" = xno; then
21831     # Now execute the test
21832 
21833   if test "x$ProgramW6432" != x; then
21834     VIRTUAL_DIR="$ProgramW6432/Java"
21835 
21836   windows_path="$VIRTUAL_DIR"
21837   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21838     unix_path=`$CYGPATH -u "$windows_path"`
21839     VIRTUAL_DIR="$unix_path"
21840   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21841     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21842     VIRTUAL_DIR="$unix_path"
21843   fi
21844 
21845 
21846   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
21847   BOOT_JDK_SUFFIX=""
21848   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
21849   if test "x$ALL_JDKS_FOUND" != x; then
21850     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
21851 
21852   if test "x$BOOT_JDK_FOUND" = xno; then
21853     # Now execute the test
21854 
21855         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
21856         if test -d "$BOOT_JDK"; then
21857           BOOT_JDK_FOUND=maybe
21858           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
21859 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
21860         fi
21861 
21862 
21863     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21864     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21865       # Do we have a bin/java?
21866       if test ! -x "$BOOT_JDK/bin/java"; then
21867         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21868 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21869         BOOT_JDK_FOUND=no
21870       else
21871         # Do we have a bin/javac?
21872         if test ! -x "$BOOT_JDK/bin/javac"; then
21873           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21874 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21875           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21876 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21877           BOOT_JDK_FOUND=no
21878         else
21879           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
21880           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
21881             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
21882 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
21883             BOOT_JDK_FOUND=no
21884           else
21885             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21886             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21887 
21888             # Extra M4 quote needed to protect [] in grep expression.
21889             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
21890             if test "x$FOUND_CORRECT_VERSION" = x; then
21891               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21892 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21893               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
21894 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
21895               BOOT_JDK_FOUND=no
21896             else
21897               # We're done! :-)
21898               BOOT_JDK_FOUND=yes
21899 
21900   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21901 
21902   # Input might be given as Windows format, start by converting to
21903   # unix format.
21904   path="$BOOT_JDK"
21905   new_path=`$CYGPATH -u "$path"`
21906 
21907   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21908   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21909   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21910   # "foo.exe" is OK but "foo" is an error.
21911   #
21912   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21913   # It is also a way to make sure we got the proper file name for the real test later on.
21914   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21915   if test "x$test_shortpath" = x; then
21916     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21917 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21918     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21919   fi
21920 
21921   # Call helper function which possibly converts this using DOS-style short mode.
21922   # If so, the updated path is stored in $new_path.
21923 
21924   input_path="$new_path"
21925   # Check if we need to convert this using DOS-style short mode. If the path
21926   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21927   # take no chances and rewrite it.
21928   # Note: m4 eats our [], so we need to use [ and ] instead.
21929   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21930   if test "x$has_forbidden_chars" != x; then
21931     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21932     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21933     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21934     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21935       # Going to short mode and back again did indeed matter. Since short mode is
21936       # case insensitive, let's make it lowercase to improve readability.
21937       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21938       # Now convert it back to Unix-stile (cygpath)
21939       input_path=`$CYGPATH -u "$shortmode_path"`
21940       new_path="$input_path"
21941     fi
21942   fi
21943 
21944   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21945   if test "x$test_cygdrive_prefix" = x; then
21946     # As a simple fix, exclude /usr/bin since it's not a real path.
21947     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21948       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21949       # a path prefixed by /cygdrive for fixpath to work.
21950       new_path="$CYGWIN_ROOT_PATH$input_path"
21951     fi
21952   fi
21953 
21954 
21955   if test "x$path" != "x$new_path"; then
21956     BOOT_JDK="$new_path"
21957     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21958 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21959   fi
21960 
21961   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21962 
21963   path="$BOOT_JDK"
21964   has_colon=`$ECHO $path | $GREP ^.:`
21965   new_path="$path"
21966   if test "x$has_colon" = x; then
21967     # Not in mixed or Windows style, start by that.
21968     new_path=`cmd //c echo $path`
21969   fi
21970 
21971 
21972   input_path="$new_path"
21973   # Check if we need to convert this using DOS-style short mode. If the path
21974   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21975   # take no chances and rewrite it.
21976   # Note: m4 eats our [], so we need to use [ and ] instead.
21977   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21978   if test "x$has_forbidden_chars" != x; then
21979     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21980     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21981   fi
21982 
21983 
21984   windows_path="$new_path"
21985   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21986     unix_path=`$CYGPATH -u "$windows_path"`
21987     new_path="$unix_path"
21988   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21989     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21990     new_path="$unix_path"
21991   fi
21992 
21993   if test "x$path" != "x$new_path"; then
21994     BOOT_JDK="$new_path"
21995     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21996 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21997   fi
21998 
21999   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22000   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22001 
22002   else
22003     # We're on a posix platform. Hooray! :)
22004     path="$BOOT_JDK"
22005     has_space=`$ECHO "$path" | $GREP " "`
22006     if test "x$has_space" != x; then
22007       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22008 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22009       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22010     fi
22011 
22012     # Use eval to expand a potential ~
22013     eval path="$path"
22014     if test ! -f "$path" && test ! -d "$path"; then
22015       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22016     fi
22017 
22018     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22019   fi
22020 
22021               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22022 $as_echo_n "checking for Boot JDK... " >&6; }
22023               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22024 $as_echo "$BOOT_JDK" >&6; }
22025               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22026 $as_echo_n "checking Boot JDK version... " >&6; }
22027               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22028               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22029 $as_echo "$BOOT_JDK_VERSION" >&6; }
22030             fi # end check jdk version
22031           fi # end check rt.jar
22032         fi # end check javac
22033       fi # end check java
22034     fi # end check boot jdk found
22035   fi
22036 
22037     done
22038   fi
22039 
22040   fi
22041 
22042 
22043     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22044     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22045       # Do we have a bin/java?
22046       if test ! -x "$BOOT_JDK/bin/java"; then
22047         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22048 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22049         BOOT_JDK_FOUND=no
22050       else
22051         # Do we have a bin/javac?
22052         if test ! -x "$BOOT_JDK/bin/javac"; then
22053           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22054 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22055           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22056 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22057           BOOT_JDK_FOUND=no
22058         else
22059           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22060           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22061             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22062 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22063             BOOT_JDK_FOUND=no
22064           else
22065             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22066             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22067 
22068             # Extra M4 quote needed to protect [] in grep expression.
22069             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
22070             if test "x$FOUND_CORRECT_VERSION" = x; then
22071               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22072 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22073               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
22074 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
22075               BOOT_JDK_FOUND=no
22076             else
22077               # We're done! :-)
22078               BOOT_JDK_FOUND=yes
22079 
22080   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22081 
22082   # Input might be given as Windows format, start by converting to
22083   # unix format.
22084   path="$BOOT_JDK"
22085   new_path=`$CYGPATH -u "$path"`
22086 
22087   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22088   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22089   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22090   # "foo.exe" is OK but "foo" is an error.
22091   #
22092   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22093   # It is also a way to make sure we got the proper file name for the real test later on.
22094   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22095   if test "x$test_shortpath" = x; then
22096     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22097 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22098     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22099   fi
22100 
22101   # Call helper function which possibly converts this using DOS-style short mode.
22102   # If so, the updated path is stored in $new_path.
22103 
22104   input_path="$new_path"
22105   # Check if we need to convert this using DOS-style short mode. If the path
22106   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22107   # take no chances and rewrite it.
22108   # Note: m4 eats our [], so we need to use [ and ] instead.
22109   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22110   if test "x$has_forbidden_chars" != x; then
22111     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22112     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22113     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22114     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22115       # Going to short mode and back again did indeed matter. Since short mode is
22116       # case insensitive, let's make it lowercase to improve readability.
22117       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22118       # Now convert it back to Unix-stile (cygpath)
22119       input_path=`$CYGPATH -u "$shortmode_path"`
22120       new_path="$input_path"
22121     fi
22122   fi
22123 
22124   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22125   if test "x$test_cygdrive_prefix" = x; then
22126     # As a simple fix, exclude /usr/bin since it's not a real path.
22127     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22128       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22129       # a path prefixed by /cygdrive for fixpath to work.
22130       new_path="$CYGWIN_ROOT_PATH$input_path"
22131     fi
22132   fi
22133 
22134 
22135   if test "x$path" != "x$new_path"; then
22136     BOOT_JDK="$new_path"
22137     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22138 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22139   fi
22140 
22141   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22142 
22143   path="$BOOT_JDK"
22144   has_colon=`$ECHO $path | $GREP ^.:`
22145   new_path="$path"
22146   if test "x$has_colon" = x; then
22147     # Not in mixed or Windows style, start by that.
22148     new_path=`cmd //c echo $path`
22149   fi
22150 
22151 
22152   input_path="$new_path"
22153   # Check if we need to convert this using DOS-style short mode. If the path
22154   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22155   # take no chances and rewrite it.
22156   # Note: m4 eats our [], so we need to use [ and ] instead.
22157   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22158   if test "x$has_forbidden_chars" != x; then
22159     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22160     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22161   fi
22162 
22163 
22164   windows_path="$new_path"
22165   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22166     unix_path=`$CYGPATH -u "$windows_path"`
22167     new_path="$unix_path"
22168   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22169     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22170     new_path="$unix_path"
22171   fi
22172 
22173   if test "x$path" != "x$new_path"; then
22174     BOOT_JDK="$new_path"
22175     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22176 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22177   fi
22178 
22179   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22180   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22181 
22182   else
22183     # We're on a posix platform. Hooray! :)
22184     path="$BOOT_JDK"
22185     has_space=`$ECHO "$path" | $GREP " "`
22186     if test "x$has_space" != x; then
22187       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22188 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22189       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22190     fi
22191 
22192     # Use eval to expand a potential ~
22193     eval path="$path"
22194     if test ! -f "$path" && test ! -d "$path"; then
22195       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22196     fi
22197 
22198     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22199   fi
22200 
22201               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22202 $as_echo_n "checking for Boot JDK... " >&6; }
22203               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22204 $as_echo "$BOOT_JDK" >&6; }
22205               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22206 $as_echo_n "checking Boot JDK version... " >&6; }
22207               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22208               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22209 $as_echo "$BOOT_JDK_VERSION" >&6; }
22210             fi # end check jdk version
22211           fi # end check rt.jar
22212         fi # end check javac
22213       fi # end check java
22214     fi # end check boot jdk found
22215   fi
22216 
22217 
22218   if test "x$BOOT_JDK_FOUND" = xno; then
22219     # Now execute the test
22220 
22221   if test "x$PROGRAMW6432" != x; then
22222     VIRTUAL_DIR="$PROGRAMW6432/Java"
22223 
22224   windows_path="$VIRTUAL_DIR"
22225   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22226     unix_path=`$CYGPATH -u "$windows_path"`
22227     VIRTUAL_DIR="$unix_path"
22228   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22229     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22230     VIRTUAL_DIR="$unix_path"
22231   fi
22232 
22233 
22234   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22235   BOOT_JDK_SUFFIX=""
22236   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22237   if test "x$ALL_JDKS_FOUND" != x; then
22238     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22239 
22240   if test "x$BOOT_JDK_FOUND" = xno; then
22241     # Now execute the test
22242 
22243         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22244         if test -d "$BOOT_JDK"; then
22245           BOOT_JDK_FOUND=maybe
22246           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22247 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22248         fi
22249 
22250 
22251     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22252     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22253       # Do we have a bin/java?
22254       if test ! -x "$BOOT_JDK/bin/java"; then
22255         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22256 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22257         BOOT_JDK_FOUND=no
22258       else
22259         # Do we have a bin/javac?
22260         if test ! -x "$BOOT_JDK/bin/javac"; then
22261           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22262 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22263           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22264 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22265           BOOT_JDK_FOUND=no
22266         else
22267           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22268           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22269             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22270 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22271             BOOT_JDK_FOUND=no
22272           else
22273             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22274             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22275 
22276             # Extra M4 quote needed to protect [] in grep expression.
22277             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
22278             if test "x$FOUND_CORRECT_VERSION" = x; then
22279               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22280 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22281               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
22282 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
22283               BOOT_JDK_FOUND=no
22284             else
22285               # We're done! :-)
22286               BOOT_JDK_FOUND=yes
22287 
22288   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22289 
22290   # Input might be given as Windows format, start by converting to
22291   # unix format.
22292   path="$BOOT_JDK"
22293   new_path=`$CYGPATH -u "$path"`
22294 
22295   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22296   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22297   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22298   # "foo.exe" is OK but "foo" is an error.
22299   #
22300   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22301   # It is also a way to make sure we got the proper file name for the real test later on.
22302   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22303   if test "x$test_shortpath" = x; then
22304     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22305 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22306     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22307   fi
22308 
22309   # Call helper function which possibly converts this using DOS-style short mode.
22310   # If so, the updated path is stored in $new_path.
22311 
22312   input_path="$new_path"
22313   # Check if we need to convert this using DOS-style short mode. If the path
22314   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22315   # take no chances and rewrite it.
22316   # Note: m4 eats our [], so we need to use [ and ] instead.
22317   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22318   if test "x$has_forbidden_chars" != x; then
22319     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22320     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22321     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22322     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22323       # Going to short mode and back again did indeed matter. Since short mode is
22324       # case insensitive, let's make it lowercase to improve readability.
22325       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22326       # Now convert it back to Unix-stile (cygpath)
22327       input_path=`$CYGPATH -u "$shortmode_path"`
22328       new_path="$input_path"
22329     fi
22330   fi
22331 
22332   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22333   if test "x$test_cygdrive_prefix" = x; then
22334     # As a simple fix, exclude /usr/bin since it's not a real path.
22335     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22336       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22337       # a path prefixed by /cygdrive for fixpath to work.
22338       new_path="$CYGWIN_ROOT_PATH$input_path"
22339     fi
22340   fi
22341 
22342 
22343   if test "x$path" != "x$new_path"; then
22344     BOOT_JDK="$new_path"
22345     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22346 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22347   fi
22348 
22349   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22350 
22351   path="$BOOT_JDK"
22352   has_colon=`$ECHO $path | $GREP ^.:`
22353   new_path="$path"
22354   if test "x$has_colon" = x; then
22355     # Not in mixed or Windows style, start by that.
22356     new_path=`cmd //c echo $path`
22357   fi
22358 
22359 
22360   input_path="$new_path"
22361   # Check if we need to convert this using DOS-style short mode. If the path
22362   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22363   # take no chances and rewrite it.
22364   # Note: m4 eats our [], so we need to use [ and ] instead.
22365   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22366   if test "x$has_forbidden_chars" != x; then
22367     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22368     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22369   fi
22370 
22371 
22372   windows_path="$new_path"
22373   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22374     unix_path=`$CYGPATH -u "$windows_path"`
22375     new_path="$unix_path"
22376   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22377     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22378     new_path="$unix_path"
22379   fi
22380 
22381   if test "x$path" != "x$new_path"; then
22382     BOOT_JDK="$new_path"
22383     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22384 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22385   fi
22386 
22387   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22388   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22389 
22390   else
22391     # We're on a posix platform. Hooray! :)
22392     path="$BOOT_JDK"
22393     has_space=`$ECHO "$path" | $GREP " "`
22394     if test "x$has_space" != x; then
22395       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22396 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22397       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22398     fi
22399 
22400     # Use eval to expand a potential ~
22401     eval path="$path"
22402     if test ! -f "$path" && test ! -d "$path"; then
22403       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22404     fi
22405 
22406     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22407   fi
22408 
22409               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22410 $as_echo_n "checking for Boot JDK... " >&6; }
22411               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22412 $as_echo "$BOOT_JDK" >&6; }
22413               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22414 $as_echo_n "checking Boot JDK version... " >&6; }
22415               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22416               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22417 $as_echo "$BOOT_JDK_VERSION" >&6; }
22418             fi # end check jdk version
22419           fi # end check rt.jar
22420         fi # end check javac
22421       fi # end check java
22422     fi # end check boot jdk found
22423   fi
22424 
22425     done
22426   fi
22427 
22428   fi
22429 
22430 
22431     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22432     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22433       # Do we have a bin/java?
22434       if test ! -x "$BOOT_JDK/bin/java"; then
22435         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22436 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22437         BOOT_JDK_FOUND=no
22438       else
22439         # Do we have a bin/javac?
22440         if test ! -x "$BOOT_JDK/bin/javac"; then
22441           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22442 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22443           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22444 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22445           BOOT_JDK_FOUND=no
22446         else
22447           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22448           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22449             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22450 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22451             BOOT_JDK_FOUND=no
22452           else
22453             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22454             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22455 
22456             # Extra M4 quote needed to protect [] in grep expression.
22457             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
22458             if test "x$FOUND_CORRECT_VERSION" = x; then
22459               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22460 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22461               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
22462 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
22463               BOOT_JDK_FOUND=no
22464             else
22465               # We're done! :-)
22466               BOOT_JDK_FOUND=yes
22467 
22468   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22469 
22470   # Input might be given as Windows format, start by converting to
22471   # unix format.
22472   path="$BOOT_JDK"
22473   new_path=`$CYGPATH -u "$path"`
22474 
22475   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22476   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22477   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22478   # "foo.exe" is OK but "foo" is an error.
22479   #
22480   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22481   # It is also a way to make sure we got the proper file name for the real test later on.
22482   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22483   if test "x$test_shortpath" = x; then
22484     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22485 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22486     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22487   fi
22488 
22489   # Call helper function which possibly converts this using DOS-style short mode.
22490   # If so, the updated path is stored in $new_path.
22491 
22492   input_path="$new_path"
22493   # Check if we need to convert this using DOS-style short mode. If the path
22494   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22495   # take no chances and rewrite it.
22496   # Note: m4 eats our [], so we need to use [ and ] instead.
22497   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22498   if test "x$has_forbidden_chars" != x; then
22499     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22500     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22501     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22502     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22503       # Going to short mode and back again did indeed matter. Since short mode is
22504       # case insensitive, let's make it lowercase to improve readability.
22505       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22506       # Now convert it back to Unix-stile (cygpath)
22507       input_path=`$CYGPATH -u "$shortmode_path"`
22508       new_path="$input_path"
22509     fi
22510   fi
22511 
22512   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22513   if test "x$test_cygdrive_prefix" = x; then
22514     # As a simple fix, exclude /usr/bin since it's not a real path.
22515     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22516       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22517       # a path prefixed by /cygdrive for fixpath to work.
22518       new_path="$CYGWIN_ROOT_PATH$input_path"
22519     fi
22520   fi
22521 
22522 
22523   if test "x$path" != "x$new_path"; then
22524     BOOT_JDK="$new_path"
22525     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22526 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22527   fi
22528 
22529   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22530 
22531   path="$BOOT_JDK"
22532   has_colon=`$ECHO $path | $GREP ^.:`
22533   new_path="$path"
22534   if test "x$has_colon" = x; then
22535     # Not in mixed or Windows style, start by that.
22536     new_path=`cmd //c echo $path`
22537   fi
22538 
22539 
22540   input_path="$new_path"
22541   # Check if we need to convert this using DOS-style short mode. If the path
22542   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22543   # take no chances and rewrite it.
22544   # Note: m4 eats our [], so we need to use [ and ] instead.
22545   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22546   if test "x$has_forbidden_chars" != x; then
22547     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22548     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22549   fi
22550 
22551 
22552   windows_path="$new_path"
22553   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22554     unix_path=`$CYGPATH -u "$windows_path"`
22555     new_path="$unix_path"
22556   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22557     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22558     new_path="$unix_path"
22559   fi
22560 
22561   if test "x$path" != "x$new_path"; then
22562     BOOT_JDK="$new_path"
22563     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22564 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22565   fi
22566 
22567   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22568   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22569 
22570   else
22571     # We're on a posix platform. Hooray! :)
22572     path="$BOOT_JDK"
22573     has_space=`$ECHO "$path" | $GREP " "`
22574     if test "x$has_space" != x; then
22575       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22576 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22577       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22578     fi
22579 
22580     # Use eval to expand a potential ~
22581     eval path="$path"
22582     if test ! -f "$path" && test ! -d "$path"; then
22583       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22584     fi
22585 
22586     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22587   fi
22588 
22589               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22590 $as_echo_n "checking for Boot JDK... " >&6; }
22591               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22592 $as_echo "$BOOT_JDK" >&6; }
22593               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22594 $as_echo_n "checking Boot JDK version... " >&6; }
22595               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22596               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22597 $as_echo "$BOOT_JDK_VERSION" >&6; }
22598             fi # end check jdk version
22599           fi # end check rt.jar
22600         fi # end check javac
22601       fi # end check java
22602     fi # end check boot jdk found
22603   fi
22604 
22605 
22606   if test "x$BOOT_JDK_FOUND" = xno; then
22607     # Now execute the test
22608 
22609   if test "x$PROGRAMFILES" != x; then
22610     VIRTUAL_DIR="$PROGRAMFILES/Java"
22611 
22612   windows_path="$VIRTUAL_DIR"
22613   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22614     unix_path=`$CYGPATH -u "$windows_path"`
22615     VIRTUAL_DIR="$unix_path"
22616   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22617     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22618     VIRTUAL_DIR="$unix_path"
22619   fi
22620 
22621 
22622   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22623   BOOT_JDK_SUFFIX=""
22624   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22625   if test "x$ALL_JDKS_FOUND" != x; then
22626     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22627 
22628   if test "x$BOOT_JDK_FOUND" = xno; then
22629     # Now execute the test
22630 
22631         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22632         if test -d "$BOOT_JDK"; then
22633           BOOT_JDK_FOUND=maybe
22634           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22635 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22636         fi
22637 
22638 
22639     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22640     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22641       # Do we have a bin/java?
22642       if test ! -x "$BOOT_JDK/bin/java"; then
22643         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22644 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22645         BOOT_JDK_FOUND=no
22646       else
22647         # Do we have a bin/javac?
22648         if test ! -x "$BOOT_JDK/bin/javac"; then
22649           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22650 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22651           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22652 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22653           BOOT_JDK_FOUND=no
22654         else
22655           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22656           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22657             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22658 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22659             BOOT_JDK_FOUND=no
22660           else
22661             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22662             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22663 
22664             # Extra M4 quote needed to protect [] in grep expression.
22665             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
22666             if test "x$FOUND_CORRECT_VERSION" = x; then
22667               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22668 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22669               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
22670 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
22671               BOOT_JDK_FOUND=no
22672             else
22673               # We're done! :-)
22674               BOOT_JDK_FOUND=yes
22675 
22676   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22677 
22678   # Input might be given as Windows format, start by converting to
22679   # unix format.
22680   path="$BOOT_JDK"
22681   new_path=`$CYGPATH -u "$path"`
22682 
22683   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22684   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22685   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22686   # "foo.exe" is OK but "foo" is an error.
22687   #
22688   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22689   # It is also a way to make sure we got the proper file name for the real test later on.
22690   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22691   if test "x$test_shortpath" = x; then
22692     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22693 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22694     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22695   fi
22696 
22697   # Call helper function which possibly converts this using DOS-style short mode.
22698   # If so, the updated path is stored in $new_path.
22699 
22700   input_path="$new_path"
22701   # Check if we need to convert this using DOS-style short mode. If the path
22702   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22703   # take no chances and rewrite it.
22704   # Note: m4 eats our [], so we need to use [ and ] instead.
22705   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22706   if test "x$has_forbidden_chars" != x; then
22707     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22708     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22709     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22710     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22711       # Going to short mode and back again did indeed matter. Since short mode is
22712       # case insensitive, let's make it lowercase to improve readability.
22713       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22714       # Now convert it back to Unix-stile (cygpath)
22715       input_path=`$CYGPATH -u "$shortmode_path"`
22716       new_path="$input_path"
22717     fi
22718   fi
22719 
22720   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22721   if test "x$test_cygdrive_prefix" = x; then
22722     # As a simple fix, exclude /usr/bin since it's not a real path.
22723     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22724       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22725       # a path prefixed by /cygdrive for fixpath to work.
22726       new_path="$CYGWIN_ROOT_PATH$input_path"
22727     fi
22728   fi
22729 
22730 
22731   if test "x$path" != "x$new_path"; then
22732     BOOT_JDK="$new_path"
22733     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22734 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22735   fi
22736 
22737   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22738 
22739   path="$BOOT_JDK"
22740   has_colon=`$ECHO $path | $GREP ^.:`
22741   new_path="$path"
22742   if test "x$has_colon" = x; then
22743     # Not in mixed or Windows style, start by that.
22744     new_path=`cmd //c echo $path`
22745   fi
22746 
22747 
22748   input_path="$new_path"
22749   # Check if we need to convert this using DOS-style short mode. If the path
22750   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22751   # take no chances and rewrite it.
22752   # Note: m4 eats our [], so we need to use [ and ] instead.
22753   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22754   if test "x$has_forbidden_chars" != x; then
22755     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22756     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22757   fi
22758 
22759 
22760   windows_path="$new_path"
22761   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22762     unix_path=`$CYGPATH -u "$windows_path"`
22763     new_path="$unix_path"
22764   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22765     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22766     new_path="$unix_path"
22767   fi
22768 
22769   if test "x$path" != "x$new_path"; then
22770     BOOT_JDK="$new_path"
22771     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22772 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22773   fi
22774 
22775   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22776   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22777 
22778   else
22779     # We're on a posix platform. Hooray! :)
22780     path="$BOOT_JDK"
22781     has_space=`$ECHO "$path" | $GREP " "`
22782     if test "x$has_space" != x; then
22783       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22784 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22785       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22786     fi
22787 
22788     # Use eval to expand a potential ~
22789     eval path="$path"
22790     if test ! -f "$path" && test ! -d "$path"; then
22791       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22792     fi
22793 
22794     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22795   fi
22796 
22797               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22798 $as_echo_n "checking for Boot JDK... " >&6; }
22799               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22800 $as_echo "$BOOT_JDK" >&6; }
22801               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22802 $as_echo_n "checking Boot JDK version... " >&6; }
22803               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22804               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22805 $as_echo "$BOOT_JDK_VERSION" >&6; }
22806             fi # end check jdk version
22807           fi # end check rt.jar
22808         fi # end check javac
22809       fi # end check java
22810     fi # end check boot jdk found
22811   fi
22812 
22813     done
22814   fi
22815 
22816   fi
22817 
22818 
22819     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22820     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22821       # Do we have a bin/java?
22822       if test ! -x "$BOOT_JDK/bin/java"; then
22823         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22824 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22825         BOOT_JDK_FOUND=no
22826       else
22827         # Do we have a bin/javac?
22828         if test ! -x "$BOOT_JDK/bin/javac"; then
22829           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22830 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22831           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22832 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22833           BOOT_JDK_FOUND=no
22834         else
22835           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22836           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22837             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22838 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22839             BOOT_JDK_FOUND=no
22840           else
22841             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22842             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22843 
22844             # Extra M4 quote needed to protect [] in grep expression.
22845             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
22846             if test "x$FOUND_CORRECT_VERSION" = x; then
22847               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22848 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22849               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
22850 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
22851               BOOT_JDK_FOUND=no
22852             else
22853               # We're done! :-)
22854               BOOT_JDK_FOUND=yes
22855 
22856   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22857 
22858   # Input might be given as Windows format, start by converting to
22859   # unix format.
22860   path="$BOOT_JDK"
22861   new_path=`$CYGPATH -u "$path"`
22862 
22863   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22864   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22865   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22866   # "foo.exe" is OK but "foo" is an error.
22867   #
22868   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22869   # It is also a way to make sure we got the proper file name for the real test later on.
22870   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22871   if test "x$test_shortpath" = x; then
22872     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22873 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22874     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22875   fi
22876 
22877   # Call helper function which possibly converts this using DOS-style short mode.
22878   # If so, the updated path is stored in $new_path.
22879 
22880   input_path="$new_path"
22881   # Check if we need to convert this using DOS-style short mode. If the path
22882   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22883   # take no chances and rewrite it.
22884   # Note: m4 eats our [], so we need to use [ and ] instead.
22885   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22886   if test "x$has_forbidden_chars" != x; then
22887     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22888     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22889     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22890     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22891       # Going to short mode and back again did indeed matter. Since short mode is
22892       # case insensitive, let's make it lowercase to improve readability.
22893       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22894       # Now convert it back to Unix-stile (cygpath)
22895       input_path=`$CYGPATH -u "$shortmode_path"`
22896       new_path="$input_path"
22897     fi
22898   fi
22899 
22900   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22901   if test "x$test_cygdrive_prefix" = x; then
22902     # As a simple fix, exclude /usr/bin since it's not a real path.
22903     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22904       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22905       # a path prefixed by /cygdrive for fixpath to work.
22906       new_path="$CYGWIN_ROOT_PATH$input_path"
22907     fi
22908   fi
22909 
22910 
22911   if test "x$path" != "x$new_path"; then
22912     BOOT_JDK="$new_path"
22913     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22914 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22915   fi
22916 
22917   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22918 
22919   path="$BOOT_JDK"
22920   has_colon=`$ECHO $path | $GREP ^.:`
22921   new_path="$path"
22922   if test "x$has_colon" = x; then
22923     # Not in mixed or Windows style, start by that.
22924     new_path=`cmd //c echo $path`
22925   fi
22926 
22927 
22928   input_path="$new_path"
22929   # Check if we need to convert this using DOS-style short mode. If the path
22930   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22931   # take no chances and rewrite it.
22932   # Note: m4 eats our [], so we need to use [ and ] instead.
22933   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22934   if test "x$has_forbidden_chars" != x; then
22935     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22936     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22937   fi
22938 
22939 
22940   windows_path="$new_path"
22941   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22942     unix_path=`$CYGPATH -u "$windows_path"`
22943     new_path="$unix_path"
22944   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22945     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22946     new_path="$unix_path"
22947   fi
22948 
22949   if test "x$path" != "x$new_path"; then
22950     BOOT_JDK="$new_path"
22951     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22952 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22953   fi
22954 
22955   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22956   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22957 
22958   else
22959     # We're on a posix platform. Hooray! :)
22960     path="$BOOT_JDK"
22961     has_space=`$ECHO "$path" | $GREP " "`
22962     if test "x$has_space" != x; then
22963       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22964 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22965       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22966     fi
22967 
22968     # Use eval to expand a potential ~
22969     eval path="$path"
22970     if test ! -f "$path" && test ! -d "$path"; then
22971       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22972     fi
22973 
22974     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22975   fi
22976 
22977               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22978 $as_echo_n "checking for Boot JDK... " >&6; }
22979               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22980 $as_echo "$BOOT_JDK" >&6; }
22981               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22982 $as_echo_n "checking Boot JDK version... " >&6; }
22983               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22984               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22985 $as_echo "$BOOT_JDK_VERSION" >&6; }
22986             fi # end check jdk version
22987           fi # end check rt.jar
22988         fi # end check javac
22989       fi # end check java
22990     fi # end check boot jdk found
22991   fi
22992 
22993 
22994   if test "x$BOOT_JDK_FOUND" = xno; then
22995     # Now execute the test
22996 
22997   if test "x$ProgramFiles" != x; then
22998     VIRTUAL_DIR="$ProgramFiles/Java"
22999 
23000   windows_path="$VIRTUAL_DIR"
23001   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23002     unix_path=`$CYGPATH -u "$windows_path"`
23003     VIRTUAL_DIR="$unix_path"
23004   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23005     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23006     VIRTUAL_DIR="$unix_path"
23007   fi
23008 
23009 
23010   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
23011   BOOT_JDK_SUFFIX=""
23012   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23013   if test "x$ALL_JDKS_FOUND" != x; then
23014     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23015 
23016   if test "x$BOOT_JDK_FOUND" = xno; then
23017     # Now execute the test
23018 
23019         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23020         if test -d "$BOOT_JDK"; then
23021           BOOT_JDK_FOUND=maybe
23022           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23023 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23024         fi
23025 
23026 
23027     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23028     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23029       # Do we have a bin/java?
23030       if test ! -x "$BOOT_JDK/bin/java"; then
23031         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23032 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23033         BOOT_JDK_FOUND=no
23034       else
23035         # Do we have a bin/javac?
23036         if test ! -x "$BOOT_JDK/bin/javac"; then
23037           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23038 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23039           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23040 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23041           BOOT_JDK_FOUND=no
23042         else
23043           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23044           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23045             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23046 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23047             BOOT_JDK_FOUND=no
23048           else
23049             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23050             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23051 
23052             # Extra M4 quote needed to protect [] in grep expression.
23053             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
23054             if test "x$FOUND_CORRECT_VERSION" = x; then
23055               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23056 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23057               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
23058 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
23059               BOOT_JDK_FOUND=no
23060             else
23061               # We're done! :-)
23062               BOOT_JDK_FOUND=yes
23063 
23064   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23065 
23066   # Input might be given as Windows format, start by converting to
23067   # unix format.
23068   path="$BOOT_JDK"
23069   new_path=`$CYGPATH -u "$path"`
23070 
23071   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23072   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23073   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23074   # "foo.exe" is OK but "foo" is an error.
23075   #
23076   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23077   # It is also a way to make sure we got the proper file name for the real test later on.
23078   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23079   if test "x$test_shortpath" = x; then
23080     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23081 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23082     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23083   fi
23084 
23085   # Call helper function which possibly converts this using DOS-style short mode.
23086   # If so, the updated path is stored in $new_path.
23087 
23088   input_path="$new_path"
23089   # Check if we need to convert this using DOS-style short mode. If the path
23090   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23091   # take no chances and rewrite it.
23092   # Note: m4 eats our [], so we need to use [ and ] instead.
23093   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23094   if test "x$has_forbidden_chars" != x; then
23095     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23096     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23097     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23098     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23099       # Going to short mode and back again did indeed matter. Since short mode is
23100       # case insensitive, let's make it lowercase to improve readability.
23101       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23102       # Now convert it back to Unix-stile (cygpath)
23103       input_path=`$CYGPATH -u "$shortmode_path"`
23104       new_path="$input_path"
23105     fi
23106   fi
23107 
23108   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23109   if test "x$test_cygdrive_prefix" = x; then
23110     # As a simple fix, exclude /usr/bin since it's not a real path.
23111     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23112       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23113       # a path prefixed by /cygdrive for fixpath to work.
23114       new_path="$CYGWIN_ROOT_PATH$input_path"
23115     fi
23116   fi
23117 
23118 
23119   if test "x$path" != "x$new_path"; then
23120     BOOT_JDK="$new_path"
23121     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23122 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23123   fi
23124 
23125   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23126 
23127   path="$BOOT_JDK"
23128   has_colon=`$ECHO $path | $GREP ^.:`
23129   new_path="$path"
23130   if test "x$has_colon" = x; then
23131     # Not in mixed or Windows style, start by that.
23132     new_path=`cmd //c echo $path`
23133   fi
23134 
23135 
23136   input_path="$new_path"
23137   # Check if we need to convert this using DOS-style short mode. If the path
23138   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23139   # take no chances and rewrite it.
23140   # Note: m4 eats our [], so we need to use [ and ] instead.
23141   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23142   if test "x$has_forbidden_chars" != x; then
23143     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23144     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23145   fi
23146 
23147 
23148   windows_path="$new_path"
23149   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23150     unix_path=`$CYGPATH -u "$windows_path"`
23151     new_path="$unix_path"
23152   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23153     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23154     new_path="$unix_path"
23155   fi
23156 
23157   if test "x$path" != "x$new_path"; then
23158     BOOT_JDK="$new_path"
23159     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23160 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23161   fi
23162 
23163   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23164   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23165 
23166   else
23167     # We're on a posix platform. Hooray! :)
23168     path="$BOOT_JDK"
23169     has_space=`$ECHO "$path" | $GREP " "`
23170     if test "x$has_space" != x; then
23171       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23172 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23173       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23174     fi
23175 
23176     # Use eval to expand a potential ~
23177     eval path="$path"
23178     if test ! -f "$path" && test ! -d "$path"; then
23179       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23180     fi
23181 
23182     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23183   fi
23184 
23185               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23186 $as_echo_n "checking for Boot JDK... " >&6; }
23187               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23188 $as_echo "$BOOT_JDK" >&6; }
23189               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23190 $as_echo_n "checking Boot JDK version... " >&6; }
23191               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23192               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23193 $as_echo "$BOOT_JDK_VERSION" >&6; }
23194             fi # end check jdk version
23195           fi # end check rt.jar
23196         fi # end check javac
23197       fi # end check java
23198     fi # end check boot jdk found
23199   fi
23200 
23201     done
23202   fi
23203 
23204   fi
23205 
23206 
23207     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23208     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23209       # Do we have a bin/java?
23210       if test ! -x "$BOOT_JDK/bin/java"; then
23211         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23212 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23213         BOOT_JDK_FOUND=no
23214       else
23215         # Do we have a bin/javac?
23216         if test ! -x "$BOOT_JDK/bin/javac"; then
23217           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23218 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23219           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23220 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23221           BOOT_JDK_FOUND=no
23222         else
23223           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23224           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23225             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23226 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23227             BOOT_JDK_FOUND=no
23228           else
23229             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23230             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23231 
23232             # Extra M4 quote needed to protect [] in grep expression.
23233             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
23234             if test "x$FOUND_CORRECT_VERSION" = x; then
23235               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23236 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23237               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
23238 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
23239               BOOT_JDK_FOUND=no
23240             else
23241               # We're done! :-)
23242               BOOT_JDK_FOUND=yes
23243 
23244   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23245 
23246   # Input might be given as Windows format, start by converting to
23247   # unix format.
23248   path="$BOOT_JDK"
23249   new_path=`$CYGPATH -u "$path"`
23250 
23251   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23252   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23253   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23254   # "foo.exe" is OK but "foo" is an error.
23255   #
23256   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23257   # It is also a way to make sure we got the proper file name for the real test later on.
23258   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23259   if test "x$test_shortpath" = x; then
23260     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23261 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23262     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23263   fi
23264 
23265   # Call helper function which possibly converts this using DOS-style short mode.
23266   # If so, the updated path is stored in $new_path.
23267 
23268   input_path="$new_path"
23269   # Check if we need to convert this using DOS-style short mode. If the path
23270   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23271   # take no chances and rewrite it.
23272   # Note: m4 eats our [], so we need to use [ and ] instead.
23273   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23274   if test "x$has_forbidden_chars" != x; then
23275     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23276     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23277     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23278     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23279       # Going to short mode and back again did indeed matter. Since short mode is
23280       # case insensitive, let's make it lowercase to improve readability.
23281       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23282       # Now convert it back to Unix-stile (cygpath)
23283       input_path=`$CYGPATH -u "$shortmode_path"`
23284       new_path="$input_path"
23285     fi
23286   fi
23287 
23288   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23289   if test "x$test_cygdrive_prefix" = x; then
23290     # As a simple fix, exclude /usr/bin since it's not a real path.
23291     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23292       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23293       # a path prefixed by /cygdrive for fixpath to work.
23294       new_path="$CYGWIN_ROOT_PATH$input_path"
23295     fi
23296   fi
23297 
23298 
23299   if test "x$path" != "x$new_path"; then
23300     BOOT_JDK="$new_path"
23301     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23302 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23303   fi
23304 
23305   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23306 
23307   path="$BOOT_JDK"
23308   has_colon=`$ECHO $path | $GREP ^.:`
23309   new_path="$path"
23310   if test "x$has_colon" = x; then
23311     # Not in mixed or Windows style, start by that.
23312     new_path=`cmd //c echo $path`
23313   fi
23314 
23315 
23316   input_path="$new_path"
23317   # Check if we need to convert this using DOS-style short mode. If the path
23318   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23319   # take no chances and rewrite it.
23320   # Note: m4 eats our [], so we need to use [ and ] instead.
23321   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23322   if test "x$has_forbidden_chars" != x; then
23323     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23324     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23325   fi
23326 
23327 
23328   windows_path="$new_path"
23329   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23330     unix_path=`$CYGPATH -u "$windows_path"`
23331     new_path="$unix_path"
23332   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23333     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23334     new_path="$unix_path"
23335   fi
23336 
23337   if test "x$path" != "x$new_path"; then
23338     BOOT_JDK="$new_path"
23339     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23340 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23341   fi
23342 
23343   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23344   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23345 
23346   else
23347     # We're on a posix platform. Hooray! :)
23348     path="$BOOT_JDK"
23349     has_space=`$ECHO "$path" | $GREP " "`
23350     if test "x$has_space" != x; then
23351       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23352 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23353       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23354     fi
23355 
23356     # Use eval to expand a potential ~
23357     eval path="$path"
23358     if test ! -f "$path" && test ! -d "$path"; then
23359       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23360     fi
23361 
23362     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23363   fi
23364 
23365               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23366 $as_echo_n "checking for Boot JDK... " >&6; }
23367               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23368 $as_echo "$BOOT_JDK" >&6; }
23369               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23370 $as_echo_n "checking Boot JDK version... " >&6; }
23371               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23372               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23373 $as_echo "$BOOT_JDK_VERSION" >&6; }
23374             fi # end check jdk version
23375           fi # end check rt.jar
23376         fi # end check javac
23377       fi # end check java
23378     fi # end check boot jdk found
23379   fi
23380 
23381 
23382   if test "x$BOOT_JDK_FOUND" = xno; then
23383     # Now execute the test
23384 
23385   BOOT_JDK_PREFIX="/cygdrive/c/Program Files/Java"
23386   BOOT_JDK_SUFFIX=""
23387   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23388   if test "x$ALL_JDKS_FOUND" != x; then
23389     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23390 
23391   if test "x$BOOT_JDK_FOUND" = xno; then
23392     # Now execute the test
23393 
23394         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23395         if test -d "$BOOT_JDK"; then
23396           BOOT_JDK_FOUND=maybe
23397           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23398 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23399         fi
23400 
23401 
23402     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23403     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23404       # Do we have a bin/java?
23405       if test ! -x "$BOOT_JDK/bin/java"; then
23406         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23407 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23408         BOOT_JDK_FOUND=no
23409       else
23410         # Do we have a bin/javac?
23411         if test ! -x "$BOOT_JDK/bin/javac"; then
23412           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23413 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23414           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23415 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23416           BOOT_JDK_FOUND=no
23417         else
23418           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23419           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23420             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23421 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23422             BOOT_JDK_FOUND=no
23423           else
23424             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23425             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23426 
23427             # Extra M4 quote needed to protect [] in grep expression.
23428             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
23429             if test "x$FOUND_CORRECT_VERSION" = x; then
23430               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23431 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23432               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
23433 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
23434               BOOT_JDK_FOUND=no
23435             else
23436               # We're done! :-)
23437               BOOT_JDK_FOUND=yes
23438 
23439   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23440 
23441   # Input might be given as Windows format, start by converting to
23442   # unix format.
23443   path="$BOOT_JDK"
23444   new_path=`$CYGPATH -u "$path"`
23445 
23446   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23447   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23448   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23449   # "foo.exe" is OK but "foo" is an error.
23450   #
23451   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23452   # It is also a way to make sure we got the proper file name for the real test later on.
23453   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23454   if test "x$test_shortpath" = x; then
23455     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23456 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23457     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23458   fi
23459 
23460   # Call helper function which possibly converts this using DOS-style short mode.
23461   # If so, the updated path is stored in $new_path.
23462 
23463   input_path="$new_path"
23464   # Check if we need to convert this using DOS-style short mode. If the path
23465   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23466   # take no chances and rewrite it.
23467   # Note: m4 eats our [], so we need to use [ and ] instead.
23468   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23469   if test "x$has_forbidden_chars" != x; then
23470     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23471     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23472     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23473     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23474       # Going to short mode and back again did indeed matter. Since short mode is
23475       # case insensitive, let's make it lowercase to improve readability.
23476       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23477       # Now convert it back to Unix-stile (cygpath)
23478       input_path=`$CYGPATH -u "$shortmode_path"`
23479       new_path="$input_path"
23480     fi
23481   fi
23482 
23483   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23484   if test "x$test_cygdrive_prefix" = x; then
23485     # As a simple fix, exclude /usr/bin since it's not a real path.
23486     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23487       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23488       # a path prefixed by /cygdrive for fixpath to work.
23489       new_path="$CYGWIN_ROOT_PATH$input_path"
23490     fi
23491   fi
23492 
23493 
23494   if test "x$path" != "x$new_path"; then
23495     BOOT_JDK="$new_path"
23496     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23497 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23498   fi
23499 
23500   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23501 
23502   path="$BOOT_JDK"
23503   has_colon=`$ECHO $path | $GREP ^.:`
23504   new_path="$path"
23505   if test "x$has_colon" = x; then
23506     # Not in mixed or Windows style, start by that.
23507     new_path=`cmd //c echo $path`
23508   fi
23509 
23510 
23511   input_path="$new_path"
23512   # Check if we need to convert this using DOS-style short mode. If the path
23513   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23514   # take no chances and rewrite it.
23515   # Note: m4 eats our [], so we need to use [ and ] instead.
23516   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23517   if test "x$has_forbidden_chars" != x; then
23518     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23519     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23520   fi
23521 
23522 
23523   windows_path="$new_path"
23524   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23525     unix_path=`$CYGPATH -u "$windows_path"`
23526     new_path="$unix_path"
23527   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23528     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23529     new_path="$unix_path"
23530   fi
23531 
23532   if test "x$path" != "x$new_path"; then
23533     BOOT_JDK="$new_path"
23534     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23535 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23536   fi
23537 
23538   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23539   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23540 
23541   else
23542     # We're on a posix platform. Hooray! :)
23543     path="$BOOT_JDK"
23544     has_space=`$ECHO "$path" | $GREP " "`
23545     if test "x$has_space" != x; then
23546       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23547 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23548       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23549     fi
23550 
23551     # Use eval to expand a potential ~
23552     eval path="$path"
23553     if test ! -f "$path" && test ! -d "$path"; then
23554       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23555     fi
23556 
23557     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23558   fi
23559 
23560               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23561 $as_echo_n "checking for Boot JDK... " >&6; }
23562               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23563 $as_echo "$BOOT_JDK" >&6; }
23564               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23565 $as_echo_n "checking Boot JDK version... " >&6; }
23566               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23567               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23568 $as_echo "$BOOT_JDK_VERSION" >&6; }
23569             fi # end check jdk version
23570           fi # end check rt.jar
23571         fi # end check javac
23572       fi # end check java
23573     fi # end check boot jdk found
23574   fi
23575 
23576     done
23577   fi
23578 
23579 
23580     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23581     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23582       # Do we have a bin/java?
23583       if test ! -x "$BOOT_JDK/bin/java"; then
23584         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23585 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23586         BOOT_JDK_FOUND=no
23587       else
23588         # Do we have a bin/javac?
23589         if test ! -x "$BOOT_JDK/bin/javac"; then
23590           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23591 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23592           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23593 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23594           BOOT_JDK_FOUND=no
23595         else
23596           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23597           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23598             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23599 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23600             BOOT_JDK_FOUND=no
23601           else
23602             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23603             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23604 
23605             # Extra M4 quote needed to protect [] in grep expression.
23606             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
23607             if test "x$FOUND_CORRECT_VERSION" = x; then
23608               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23609 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23610               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
23611 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
23612               BOOT_JDK_FOUND=no
23613             else
23614               # We're done! :-)
23615               BOOT_JDK_FOUND=yes
23616 
23617   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23618 
23619   # Input might be given as Windows format, start by converting to
23620   # unix format.
23621   path="$BOOT_JDK"
23622   new_path=`$CYGPATH -u "$path"`
23623 
23624   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23625   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23626   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23627   # "foo.exe" is OK but "foo" is an error.
23628   #
23629   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23630   # It is also a way to make sure we got the proper file name for the real test later on.
23631   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23632   if test "x$test_shortpath" = x; then
23633     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23634 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23635     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23636   fi
23637 
23638   # Call helper function which possibly converts this using DOS-style short mode.
23639   # If so, the updated path is stored in $new_path.
23640 
23641   input_path="$new_path"
23642   # Check if we need to convert this using DOS-style short mode. If the path
23643   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23644   # take no chances and rewrite it.
23645   # Note: m4 eats our [], so we need to use [ and ] instead.
23646   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23647   if test "x$has_forbidden_chars" != x; then
23648     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23649     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23650     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23651     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23652       # Going to short mode and back again did indeed matter. Since short mode is
23653       # case insensitive, let's make it lowercase to improve readability.
23654       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23655       # Now convert it back to Unix-stile (cygpath)
23656       input_path=`$CYGPATH -u "$shortmode_path"`
23657       new_path="$input_path"
23658     fi
23659   fi
23660 
23661   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23662   if test "x$test_cygdrive_prefix" = x; then
23663     # As a simple fix, exclude /usr/bin since it's not a real path.
23664     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23665       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23666       # a path prefixed by /cygdrive for fixpath to work.
23667       new_path="$CYGWIN_ROOT_PATH$input_path"
23668     fi
23669   fi
23670 
23671 
23672   if test "x$path" != "x$new_path"; then
23673     BOOT_JDK="$new_path"
23674     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23675 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23676   fi
23677 
23678   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23679 
23680   path="$BOOT_JDK"
23681   has_colon=`$ECHO $path | $GREP ^.:`
23682   new_path="$path"
23683   if test "x$has_colon" = x; then
23684     # Not in mixed or Windows style, start by that.
23685     new_path=`cmd //c echo $path`
23686   fi
23687 
23688 
23689   input_path="$new_path"
23690   # Check if we need to convert this using DOS-style short mode. If the path
23691   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23692   # take no chances and rewrite it.
23693   # Note: m4 eats our [], so we need to use [ and ] instead.
23694   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23695   if test "x$has_forbidden_chars" != x; then
23696     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23697     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23698   fi
23699 
23700 
23701   windows_path="$new_path"
23702   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23703     unix_path=`$CYGPATH -u "$windows_path"`
23704     new_path="$unix_path"
23705   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23706     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23707     new_path="$unix_path"
23708   fi
23709 
23710   if test "x$path" != "x$new_path"; then
23711     BOOT_JDK="$new_path"
23712     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23713 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23714   fi
23715 
23716   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23717   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23718 
23719   else
23720     # We're on a posix platform. Hooray! :)
23721     path="$BOOT_JDK"
23722     has_space=`$ECHO "$path" | $GREP " "`
23723     if test "x$has_space" != x; then
23724       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23725 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23726       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23727     fi
23728 
23729     # Use eval to expand a potential ~
23730     eval path="$path"
23731     if test ! -f "$path" && test ! -d "$path"; then
23732       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23733     fi
23734 
23735     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23736   fi
23737 
23738               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23739 $as_echo_n "checking for Boot JDK... " >&6; }
23740               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23741 $as_echo "$BOOT_JDK" >&6; }
23742               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23743 $as_echo_n "checking Boot JDK version... " >&6; }
23744               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23745               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23746 $as_echo "$BOOT_JDK_VERSION" >&6; }
23747             fi # end check jdk version
23748           fi # end check rt.jar
23749         fi # end check javac
23750       fi # end check java
23751     fi # end check boot jdk found
23752   fi
23753 
23754   elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
23755 
23756   if test "x$BOOT_JDK_FOUND" = xno; then
23757     # Now execute the test
23758 
23759   BOOT_JDK_PREFIX="/Library/Java/JavaVirtualMachines"
23760   BOOT_JDK_SUFFIX="/Contents/Home"
23761   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23762   if test "x$ALL_JDKS_FOUND" != x; then
23763     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23764 
23765   if test "x$BOOT_JDK_FOUND" = xno; then
23766     # Now execute the test
23767 
23768         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23769         if test -d "$BOOT_JDK"; then
23770           BOOT_JDK_FOUND=maybe
23771           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23772 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23773         fi
23774 
23775 
23776     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23777     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23778       # Do we have a bin/java?
23779       if test ! -x "$BOOT_JDK/bin/java"; then
23780         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23781 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23782         BOOT_JDK_FOUND=no
23783       else
23784         # Do we have a bin/javac?
23785         if test ! -x "$BOOT_JDK/bin/javac"; then
23786           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23787 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23788           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23789 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23790           BOOT_JDK_FOUND=no
23791         else
23792           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23793           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23794             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23795 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23796             BOOT_JDK_FOUND=no
23797           else
23798             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23799             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23800 
23801             # Extra M4 quote needed to protect [] in grep expression.
23802             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
23803             if test "x$FOUND_CORRECT_VERSION" = x; then
23804               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23805 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23806               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
23807 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
23808               BOOT_JDK_FOUND=no
23809             else
23810               # We're done! :-)
23811               BOOT_JDK_FOUND=yes
23812 
23813   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23814 
23815   # Input might be given as Windows format, start by converting to
23816   # unix format.
23817   path="$BOOT_JDK"
23818   new_path=`$CYGPATH -u "$path"`
23819 
23820   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23821   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23822   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23823   # "foo.exe" is OK but "foo" is an error.
23824   #
23825   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23826   # It is also a way to make sure we got the proper file name for the real test later on.
23827   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23828   if test "x$test_shortpath" = x; then
23829     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23830 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23831     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23832   fi
23833 
23834   # Call helper function which possibly converts this using DOS-style short mode.
23835   # If so, the updated path is stored in $new_path.
23836 
23837   input_path="$new_path"
23838   # Check if we need to convert this using DOS-style short mode. If the path
23839   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23840   # take no chances and rewrite it.
23841   # Note: m4 eats our [], so we need to use [ and ] instead.
23842   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23843   if test "x$has_forbidden_chars" != x; then
23844     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23845     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23846     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23847     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23848       # Going to short mode and back again did indeed matter. Since short mode is
23849       # case insensitive, let's make it lowercase to improve readability.
23850       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23851       # Now convert it back to Unix-stile (cygpath)
23852       input_path=`$CYGPATH -u "$shortmode_path"`
23853       new_path="$input_path"
23854     fi
23855   fi
23856 
23857   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23858   if test "x$test_cygdrive_prefix" = x; then
23859     # As a simple fix, exclude /usr/bin since it's not a real path.
23860     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23861       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23862       # a path prefixed by /cygdrive for fixpath to work.
23863       new_path="$CYGWIN_ROOT_PATH$input_path"
23864     fi
23865   fi
23866 
23867 
23868   if test "x$path" != "x$new_path"; then
23869     BOOT_JDK="$new_path"
23870     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23871 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23872   fi
23873 
23874   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23875 
23876   path="$BOOT_JDK"
23877   has_colon=`$ECHO $path | $GREP ^.:`
23878   new_path="$path"
23879   if test "x$has_colon" = x; then
23880     # Not in mixed or Windows style, start by that.
23881     new_path=`cmd //c echo $path`
23882   fi
23883 
23884 
23885   input_path="$new_path"
23886   # Check if we need to convert this using DOS-style short mode. If the path
23887   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23888   # take no chances and rewrite it.
23889   # Note: m4 eats our [], so we need to use [ and ] instead.
23890   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23891   if test "x$has_forbidden_chars" != x; then
23892     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23893     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23894   fi
23895 
23896 
23897   windows_path="$new_path"
23898   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23899     unix_path=`$CYGPATH -u "$windows_path"`
23900     new_path="$unix_path"
23901   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23902     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23903     new_path="$unix_path"
23904   fi
23905 
23906   if test "x$path" != "x$new_path"; then
23907     BOOT_JDK="$new_path"
23908     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23909 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23910   fi
23911 
23912   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23913   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23914 
23915   else
23916     # We're on a posix platform. Hooray! :)
23917     path="$BOOT_JDK"
23918     has_space=`$ECHO "$path" | $GREP " "`
23919     if test "x$has_space" != x; then
23920       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23921 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23922       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23923     fi
23924 
23925     # Use eval to expand a potential ~
23926     eval path="$path"
23927     if test ! -f "$path" && test ! -d "$path"; then
23928       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23929     fi
23930 
23931     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23932   fi
23933 
23934               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23935 $as_echo_n "checking for Boot JDK... " >&6; }
23936               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23937 $as_echo "$BOOT_JDK" >&6; }
23938               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23939 $as_echo_n "checking Boot JDK version... " >&6; }
23940               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23941               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23942 $as_echo "$BOOT_JDK_VERSION" >&6; }
23943             fi # end check jdk version
23944           fi # end check rt.jar
23945         fi # end check javac
23946       fi # end check java
23947     fi # end check boot jdk found
23948   fi
23949 
23950     done
23951   fi
23952 
23953 
23954     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23955     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23956       # Do we have a bin/java?
23957       if test ! -x "$BOOT_JDK/bin/java"; then
23958         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23959 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23960         BOOT_JDK_FOUND=no
23961       else
23962         # Do we have a bin/javac?
23963         if test ! -x "$BOOT_JDK/bin/javac"; then
23964           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23965 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23966           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23967 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23968           BOOT_JDK_FOUND=no
23969         else
23970           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23971           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23972             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23973 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23974             BOOT_JDK_FOUND=no
23975           else
23976             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23977             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23978 
23979             # Extra M4 quote needed to protect [] in grep expression.
23980             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
23981             if test "x$FOUND_CORRECT_VERSION" = x; then
23982               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23983 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23984               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
23985 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
23986               BOOT_JDK_FOUND=no
23987             else
23988               # We're done! :-)
23989               BOOT_JDK_FOUND=yes
23990 
23991   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23992 
23993   # Input might be given as Windows format, start by converting to
23994   # unix format.
23995   path="$BOOT_JDK"
23996   new_path=`$CYGPATH -u "$path"`
23997 
23998   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23999   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24000   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24001   # "foo.exe" is OK but "foo" is an error.
24002   #
24003   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24004   # It is also a way to make sure we got the proper file name for the real test later on.
24005   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24006   if test "x$test_shortpath" = x; then
24007     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24008 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24009     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24010   fi
24011 
24012   # Call helper function which possibly converts this using DOS-style short mode.
24013   # If so, the updated path is stored in $new_path.
24014 
24015   input_path="$new_path"
24016   # Check if we need to convert this using DOS-style short mode. If the path
24017   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24018   # take no chances and rewrite it.
24019   # Note: m4 eats our [], so we need to use [ and ] instead.
24020   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24021   if test "x$has_forbidden_chars" != x; then
24022     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24023     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24024     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24025     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24026       # Going to short mode and back again did indeed matter. Since short mode is
24027       # case insensitive, let's make it lowercase to improve readability.
24028       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24029       # Now convert it back to Unix-stile (cygpath)
24030       input_path=`$CYGPATH -u "$shortmode_path"`
24031       new_path="$input_path"
24032     fi
24033   fi
24034 
24035   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24036   if test "x$test_cygdrive_prefix" = x; then
24037     # As a simple fix, exclude /usr/bin since it's not a real path.
24038     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24039       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24040       # a path prefixed by /cygdrive for fixpath to work.
24041       new_path="$CYGWIN_ROOT_PATH$input_path"
24042     fi
24043   fi
24044 
24045 
24046   if test "x$path" != "x$new_path"; then
24047     BOOT_JDK="$new_path"
24048     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24049 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24050   fi
24051 
24052   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24053 
24054   path="$BOOT_JDK"
24055   has_colon=`$ECHO $path | $GREP ^.:`
24056   new_path="$path"
24057   if test "x$has_colon" = x; then
24058     # Not in mixed or Windows style, start by that.
24059     new_path=`cmd //c echo $path`
24060   fi
24061 
24062 
24063   input_path="$new_path"
24064   # Check if we need to convert this using DOS-style short mode. If the path
24065   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24066   # take no chances and rewrite it.
24067   # Note: m4 eats our [], so we need to use [ and ] instead.
24068   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24069   if test "x$has_forbidden_chars" != x; then
24070     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24071     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24072   fi
24073 
24074 
24075   windows_path="$new_path"
24076   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24077     unix_path=`$CYGPATH -u "$windows_path"`
24078     new_path="$unix_path"
24079   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24080     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24081     new_path="$unix_path"
24082   fi
24083 
24084   if test "x$path" != "x$new_path"; then
24085     BOOT_JDK="$new_path"
24086     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24087 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24088   fi
24089 
24090   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24091   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24092 
24093   else
24094     # We're on a posix platform. Hooray! :)
24095     path="$BOOT_JDK"
24096     has_space=`$ECHO "$path" | $GREP " "`
24097     if test "x$has_space" != x; then
24098       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24099 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24100       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24101     fi
24102 
24103     # Use eval to expand a potential ~
24104     eval path="$path"
24105     if test ! -f "$path" && test ! -d "$path"; then
24106       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24107     fi
24108 
24109     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24110   fi
24111 
24112               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24113 $as_echo_n "checking for Boot JDK... " >&6; }
24114               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24115 $as_echo "$BOOT_JDK" >&6; }
24116               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24117 $as_echo_n "checking Boot JDK version... " >&6; }
24118               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24119               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24120 $as_echo "$BOOT_JDK_VERSION" >&6; }
24121             fi # end check jdk version
24122           fi # end check rt.jar
24123         fi # end check javac
24124       fi # end check java
24125     fi # end check boot jdk found
24126   fi
24127 
24128 
24129   if test "x$BOOT_JDK_FOUND" = xno; then
24130     # Now execute the test
24131 
24132   BOOT_JDK_PREFIX="/System/Library/Java/JavaVirtualMachines"
24133   BOOT_JDK_SUFFIX="/Contents/Home"
24134   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24135   if test "x$ALL_JDKS_FOUND" != x; then
24136     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24137 
24138   if test "x$BOOT_JDK_FOUND" = xno; then
24139     # Now execute the test
24140 
24141         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24142         if test -d "$BOOT_JDK"; then
24143           BOOT_JDK_FOUND=maybe
24144           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24145 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24146         fi
24147 
24148 
24149     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24150     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24151       # Do we have a bin/java?
24152       if test ! -x "$BOOT_JDK/bin/java"; then
24153         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24154 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24155         BOOT_JDK_FOUND=no
24156       else
24157         # Do we have a bin/javac?
24158         if test ! -x "$BOOT_JDK/bin/javac"; then
24159           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24160 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24161           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24162 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24163           BOOT_JDK_FOUND=no
24164         else
24165           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
24166           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
24167             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
24168 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
24169             BOOT_JDK_FOUND=no
24170           else
24171             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24172             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24173 
24174             # Extra M4 quote needed to protect [] in grep expression.
24175             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
24176             if test "x$FOUND_CORRECT_VERSION" = x; then
24177               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24178 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24179               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
24180 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
24181               BOOT_JDK_FOUND=no
24182             else
24183               # We're done! :-)
24184               BOOT_JDK_FOUND=yes
24185 
24186   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24187 
24188   # Input might be given as Windows format, start by converting to
24189   # unix format.
24190   path="$BOOT_JDK"
24191   new_path=`$CYGPATH -u "$path"`
24192 
24193   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24194   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24195   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24196   # "foo.exe" is OK but "foo" is an error.
24197   #
24198   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24199   # It is also a way to make sure we got the proper file name for the real test later on.
24200   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24201   if test "x$test_shortpath" = x; then
24202     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24203 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24204     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24205   fi
24206 
24207   # Call helper function which possibly converts this using DOS-style short mode.
24208   # If so, the updated path is stored in $new_path.
24209 
24210   input_path="$new_path"
24211   # Check if we need to convert this using DOS-style short mode. If the path
24212   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24213   # take no chances and rewrite it.
24214   # Note: m4 eats our [], so we need to use [ and ] instead.
24215   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24216   if test "x$has_forbidden_chars" != x; then
24217     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24218     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24219     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24220     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24221       # Going to short mode and back again did indeed matter. Since short mode is
24222       # case insensitive, let's make it lowercase to improve readability.
24223       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24224       # Now convert it back to Unix-stile (cygpath)
24225       input_path=`$CYGPATH -u "$shortmode_path"`
24226       new_path="$input_path"
24227     fi
24228   fi
24229 
24230   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24231   if test "x$test_cygdrive_prefix" = x; then
24232     # As a simple fix, exclude /usr/bin since it's not a real path.
24233     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24234       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24235       # a path prefixed by /cygdrive for fixpath to work.
24236       new_path="$CYGWIN_ROOT_PATH$input_path"
24237     fi
24238   fi
24239 
24240 
24241   if test "x$path" != "x$new_path"; then
24242     BOOT_JDK="$new_path"
24243     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24244 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24245   fi
24246 
24247   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24248 
24249   path="$BOOT_JDK"
24250   has_colon=`$ECHO $path | $GREP ^.:`
24251   new_path="$path"
24252   if test "x$has_colon" = x; then
24253     # Not in mixed or Windows style, start by that.
24254     new_path=`cmd //c echo $path`
24255   fi
24256 
24257 
24258   input_path="$new_path"
24259   # Check if we need to convert this using DOS-style short mode. If the path
24260   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24261   # take no chances and rewrite it.
24262   # Note: m4 eats our [], so we need to use [ and ] instead.
24263   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24264   if test "x$has_forbidden_chars" != x; then
24265     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24266     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24267   fi
24268 
24269 
24270   windows_path="$new_path"
24271   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24272     unix_path=`$CYGPATH -u "$windows_path"`
24273     new_path="$unix_path"
24274   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24275     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24276     new_path="$unix_path"
24277   fi
24278 
24279   if test "x$path" != "x$new_path"; then
24280     BOOT_JDK="$new_path"
24281     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24282 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24283   fi
24284 
24285   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24286   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24287 
24288   else
24289     # We're on a posix platform. Hooray! :)
24290     path="$BOOT_JDK"
24291     has_space=`$ECHO "$path" | $GREP " "`
24292     if test "x$has_space" != x; then
24293       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24294 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24295       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24296     fi
24297 
24298     # Use eval to expand a potential ~
24299     eval path="$path"
24300     if test ! -f "$path" && test ! -d "$path"; then
24301       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24302     fi
24303 
24304     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24305   fi
24306 
24307               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24308 $as_echo_n "checking for Boot JDK... " >&6; }
24309               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24310 $as_echo "$BOOT_JDK" >&6; }
24311               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24312 $as_echo_n "checking Boot JDK version... " >&6; }
24313               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24314               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24315 $as_echo "$BOOT_JDK_VERSION" >&6; }
24316             fi # end check jdk version
24317           fi # end check rt.jar
24318         fi # end check javac
24319       fi # end check java
24320     fi # end check boot jdk found
24321   fi
24322 
24323     done
24324   fi
24325 
24326 
24327     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24328     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24329       # Do we have a bin/java?
24330       if test ! -x "$BOOT_JDK/bin/java"; then
24331         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24332 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24333         BOOT_JDK_FOUND=no
24334       else
24335         # Do we have a bin/javac?
24336         if test ! -x "$BOOT_JDK/bin/javac"; then
24337           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24338 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24339           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24340 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24341           BOOT_JDK_FOUND=no
24342         else
24343           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
24344           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
24345             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
24346 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
24347             BOOT_JDK_FOUND=no
24348           else
24349             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24350             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24351 
24352             # Extra M4 quote needed to protect [] in grep expression.
24353             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
24354             if test "x$FOUND_CORRECT_VERSION" = x; then
24355               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24356 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24357               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
24358 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
24359               BOOT_JDK_FOUND=no
24360             else
24361               # We're done! :-)
24362               BOOT_JDK_FOUND=yes
24363 
24364   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24365 
24366   # Input might be given as Windows format, start by converting to
24367   # unix format.
24368   path="$BOOT_JDK"
24369   new_path=`$CYGPATH -u "$path"`
24370 
24371   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24372   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24373   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24374   # "foo.exe" is OK but "foo" is an error.
24375   #
24376   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24377   # It is also a way to make sure we got the proper file name for the real test later on.
24378   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24379   if test "x$test_shortpath" = x; then
24380     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24381 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24382     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24383   fi
24384 
24385   # Call helper function which possibly converts this using DOS-style short mode.
24386   # If so, the updated path is stored in $new_path.
24387 
24388   input_path="$new_path"
24389   # Check if we need to convert this using DOS-style short mode. If the path
24390   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24391   # take no chances and rewrite it.
24392   # Note: m4 eats our [], so we need to use [ and ] instead.
24393   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24394   if test "x$has_forbidden_chars" != x; then
24395     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24396     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24397     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24398     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24399       # Going to short mode and back again did indeed matter. Since short mode is
24400       # case insensitive, let's make it lowercase to improve readability.
24401       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24402       # Now convert it back to Unix-stile (cygpath)
24403       input_path=`$CYGPATH -u "$shortmode_path"`
24404       new_path="$input_path"
24405     fi
24406   fi
24407 
24408   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24409   if test "x$test_cygdrive_prefix" = x; then
24410     # As a simple fix, exclude /usr/bin since it's not a real path.
24411     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24412       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24413       # a path prefixed by /cygdrive for fixpath to work.
24414       new_path="$CYGWIN_ROOT_PATH$input_path"
24415     fi
24416   fi
24417 
24418 
24419   if test "x$path" != "x$new_path"; then
24420     BOOT_JDK="$new_path"
24421     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24422 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24423   fi
24424 
24425   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24426 
24427   path="$BOOT_JDK"
24428   has_colon=`$ECHO $path | $GREP ^.:`
24429   new_path="$path"
24430   if test "x$has_colon" = x; then
24431     # Not in mixed or Windows style, start by that.
24432     new_path=`cmd //c echo $path`
24433   fi
24434 
24435 
24436   input_path="$new_path"
24437   # Check if we need to convert this using DOS-style short mode. If the path
24438   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24439   # take no chances and rewrite it.
24440   # Note: m4 eats our [], so we need to use [ and ] instead.
24441   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24442   if test "x$has_forbidden_chars" != x; then
24443     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24444     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24445   fi
24446 
24447 
24448   windows_path="$new_path"
24449   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24450     unix_path=`$CYGPATH -u "$windows_path"`
24451     new_path="$unix_path"
24452   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24453     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24454     new_path="$unix_path"
24455   fi
24456 
24457   if test "x$path" != "x$new_path"; then
24458     BOOT_JDK="$new_path"
24459     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24460 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24461   fi
24462 
24463   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24464   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24465 
24466   else
24467     # We're on a posix platform. Hooray! :)
24468     path="$BOOT_JDK"
24469     has_space=`$ECHO "$path" | $GREP " "`
24470     if test "x$has_space" != x; then
24471       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24472 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24473       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24474     fi
24475 
24476     # Use eval to expand a potential ~
24477     eval path="$path"
24478     if test ! -f "$path" && test ! -d "$path"; then
24479       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24480     fi
24481 
24482     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24483   fi
24484 
24485               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24486 $as_echo_n "checking for Boot JDK... " >&6; }
24487               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24488 $as_echo "$BOOT_JDK" >&6; }
24489               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24490 $as_echo_n "checking Boot JDK version... " >&6; }
24491               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24492               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24493 $as_echo "$BOOT_JDK_VERSION" >&6; }
24494             fi # end check jdk version
24495           fi # end check rt.jar
24496         fi # end check javac
24497       fi # end check java
24498     fi # end check boot jdk found
24499   fi
24500 
24501   elif test "x$OPENJDK_TARGET_OS" = xlinux; then
24502 
24503   if test "x$BOOT_JDK_FOUND" = xno; then
24504     # Now execute the test
24505 
24506   BOOT_JDK_PREFIX="/usr/lib/jvm"
24507   BOOT_JDK_SUFFIX=""
24508   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24509   if test "x$ALL_JDKS_FOUND" != x; then
24510     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24511 
24512   if test "x$BOOT_JDK_FOUND" = xno; then
24513     # Now execute the test
24514 
24515         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24516         if test -d "$BOOT_JDK"; then
24517           BOOT_JDK_FOUND=maybe
24518           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24519 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24520         fi
24521 
24522 
24523     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24524     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24525       # Do we have a bin/java?
24526       if test ! -x "$BOOT_JDK/bin/java"; then
24527         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24528 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24529         BOOT_JDK_FOUND=no
24530       else
24531         # Do we have a bin/javac?
24532         if test ! -x "$BOOT_JDK/bin/javac"; then
24533           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24534 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24535           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24536 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24537           BOOT_JDK_FOUND=no
24538         else
24539           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
24540           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
24541             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
24542 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
24543             BOOT_JDK_FOUND=no
24544           else
24545             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24546             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24547 
24548             # Extra M4 quote needed to protect [] in grep expression.
24549             FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[789]\.'`
24550             if test "x$FOUND_CORRECT_VERSION" = x; then
24551               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24552 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24553               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7, 8 or 9)" >&5
24554 $as_echo "$as_me: (Your Boot JDK must be version 7, 8 or 9)" >&6;}
24555               BOOT_JDK_FOUND=no
24556             else
24557               # We're done! :-)
24558               BOOT_JDK_FOUND=yes
24559 
24560   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24561 
24562   # Input might be given as Windows format, start by converting to
24563   # unix format.
24564   path="$BOOT_JDK"
24565   new_path=`$CYGPATH -u "$path"`
24566 
24567   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24568   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24569   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24570   # "foo.exe" is OK but "foo" is an error.
24571   #
24572   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24573   # It is also a way to make sure we got the proper file name for the real test later on.
24574   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24575   if test "x$test_shortpath" = x; then
24576     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24577 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24578     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24579   fi
24580 
24581   # Call helper function which possibly converts this using DOS-style short mode.
24582   # If so, the updated path is stored in $new_path.
24583 
24584   input_path="$new_path"
24585   # Check if we need to convert this using DOS-style short mode. If the path
24586   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24587   # take no chances and rewrite it.
24588   # Note: m4 eats our [], so we need to use [ and ] instead.
24589   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24590   if test "x$has_forbidden_chars" != x; then
24591     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24592     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24593     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24594     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24595       # Going to short mode and back again did indeed matter. Since short mode is
24596       # case insensitive, let's make it lowercase to improve readability.
24597       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24598       # Now convert it back to Unix-stile (cygpath)
24599       input_path=`$CYGPATH -u "$shortmode_path"`
24600       new_path="$input_path"
24601     fi
24602   fi
24603 
24604   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24605   if test "x$test_cygdrive_prefix" = x; then
24606     # As a simple fix, exclude /usr/bin since it's not a real path.
24607     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24608       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24609       # a path prefixed by /cygdrive for fixpath to work.
24610       new_path="$CYGWIN_ROOT_PATH$input_path"
24611     fi
24612   fi
24613 
24614 
24615   if test "x$path" != "x$new_path"; then
24616     BOOT_JDK="$new_path"
24617     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24618 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24619   fi
24620 
24621   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24622 
24623   path="$BOOT_JDK"
24624   has_colon=`$ECHO $path | $GREP ^.:`
24625   new_path="$path"
24626   if test "x$has_colon" = x; then
24627     # Not in mixed or Windows style, start by that.
24628     new_path=`cmd //c echo $path`
24629   fi
24630 
24631 
24632   input_path="$new_path"
24633   # Check if we need to convert this using DOS-style short mode. If the path
24634   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24635   # take no chances and rewrite it.
24636   # Note: m4 eats our [], so we need to use [ and ] instead.
24637   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24638   if test "x$has_forbidden_chars" != x; then
24639     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24640     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24641   fi
24642 
24643 
24644   windows_path="$new_path"
24645   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24646     unix_path=`$CYGPATH -u "$windows_path"`
24647     new_path="$unix_path"
24648   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24649     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24650     new_path="$unix_path"
24651   fi
24652 
24653   if test "x$path" != "x$new_path"; then
24654     BOOT_JDK="$new_path"
24655     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24656 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24657   fi
24658 
24659   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24660   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24661 
24662   else
24663     # We're on a posix platform. Hooray! :)
24664     pat