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 jdk8.
  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='jdk8'
 590 PACKAGE_STRING='OpenJDK jdk8'
 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 UCRT_DLL_DIR
 644 MSVCP_DLL
 645 MSVCR_DLL
 646 LIBCXX
 647 LLVM_LIBS
 648 LLVM_LDFLAGS
 649 LLVM_CFLAGS
 650 LLVM_CONFIG
 651 LIBFFI_LIBS
 652 LIBFFI_CFLAGS
 653 STATIC_CXX_SETTING
 654 LIBDL
 655 LIBM
 656 LIBZIP_CAN_USE_MMAP
 657 USE_EXTERNAL_LIBZ
 658 USE_EXTERNAL_LIBGIF
 659 USE_EXTERNAL_LIBJPEG
 660 FONTCONFIG_CFLAGS
 661 ALSA_LIBS
 662 ALSA_CFLAGS
 663 FREETYPE_BUNDLE_LIB_PATH
 664 FREETYPE_LIBS
 665 FREETYPE_CFLAGS
 666 CUPS_CFLAGS
 667 X_EXTRA_LIBS
 668 X_LIBS
 669 X_PRE_LIBS
 670 X_CFLAGS
 671 XMKMF
 672 FIXPATH
 673 ZIP_DEBUGINFO_FILES
 674 DEBUG_BINARIES
 675 STRIP_POLICY
 676 ENABLE_DEBUG_SYMBOLS
 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 FDLIBM_CFLAGS
 690 NO_LIFETIME_DSE_CFLAG
 691 NO_DELETE_NULL_POINTER_CHECKS_CFLAG
 692 LEGACY_EXTRA_ASFLAGS
 693 LEGACY_EXTRA_LDFLAGS
 694 LEGACY_EXTRA_CXXFLAGS
 695 LEGACY_EXTRA_CFLAGS
 696 CXXSTD_CXXFLAG
 697 CXX_O_FLAG_NONE
 698 CXX_O_FLAG_NORM
 699 CXX_O_FLAG_HI
 700 CXX_O_FLAG_HIGHEST
 701 C_O_FLAG_NONE
 702 C_O_FLAG_NORM
 703 C_O_FLAG_HI
 704 C_O_FLAG_HIGHEST
 705 CXXFLAGS_DEBUG_SYMBOLS
 706 CFLAGS_DEBUG_SYMBOLS
 707 ASFLAGS_DEBUG_SYMBOLS
 708 CXX_FLAG_DEPS
 709 C_FLAG_DEPS
 710 SET_SHARED_LIBRARY_MAPFILE
 711 SET_SHARED_LIBRARY_NAME
 712 SET_SHARED_LIBRARY_ORIGIN
 713 SET_EXECUTABLE_ORIGIN
 714 SHARED_LIBRARY_FLAGS
 715 CXX_FLAG_REORDER
 716 C_FLAG_REORDER
 717 SYSROOT_LDFLAGS
 718 SYSROOT_CFLAGS
 719 RC_FLAGS
 720 AR_OUT_OPTION
 721 LD_OUT_OPTION
 722 EXE_OUT_OPTION
 723 CC_OUT_OPTION
 724 POST_MCS_CMD
 725 POST_STRIP_CMD
 726 ARFLAGS
 727 COMPILER_TARGET_BITS_FLAG
 728 JT_HOME
 729 JTREGEXE
 730 USING_BROKEN_SUSE_LD
 731 PACKAGE_PATH
 732 LDEXECXX
 733 LDEXE
 734 USE_CLANG
 735 HOTSPOT_LD
 736 HOTSPOT_CXX
 737 HOTSPOT_RC
 738 HOTSPOT_MT
 739 BUILD_LD
 740 BUILD_CXX
 741 BUILD_CC
 742 ac_ct_OBJDUMP
 743 OBJDUMP
 744 ac_ct_OBJCOPY
 745 OBJCOPY
 746 ac_ct_NM
 747 OTOOL
 748 ac_ct_STRIP
 749 MCS
 750 GNM
 751 NM
 752 STRIP
 753 MSBUILD
 754 DUMPBIN
 755 RC
 756 MT
 757 LIPO
 758 ac_ct_OBJC
 759 OBJCFLAGS
 760 OBJC
 761 ac_ct_AR
 762 AR
 763 AS
 764 LDCXX
 765 LD
 766 CXXCPP
 767 CPP
 768 CXX_VERSION_NUMBER
 769 CC_VERSION_NUMBER
 770 ac_ct_CXX
 771 CXXFLAGS
 772 CXX
 773 ac_ct_PROPER_COMPILER_CXX
 774 PROPER_COMPILER_CXX
 775 TOOLCHAIN_PATH_CXX
 776 POTENTIAL_CXX
 777 OBJEXT
 778 EXEEXT
 779 ac_ct_CC
 780 CPPFLAGS
 781 LDFLAGS
 782 CFLAGS
 783 CC
 784 ac_ct_PROPER_COMPILER_CC
 785 PROPER_COMPILER_CC
 786 TOOLCHAIN_PATH_CC
 787 POTENTIAL_CC
 788 SDKPATH
 789 XCODEBUILD
 790 SET_DEVELOPER_DIR
 791 VS_LIB
 792 VS_INCLUDE
 793 VS_PATH
 794 CYGWIN_LINK
 795 EXE_SUFFIX
 796 OBJ_SUFFIX
 797 STATIC_LIBRARY
 798 SHARED_LIBRARY
 799 STATIC_LIBRARY_SUFFIX
 800 SHARED_LIBRARY_SUFFIX
 801 LIBRARY_PREFIX
 802 TOOLCHAIN_TYPE
 803 BUILD_HOTSPOT
 804 HOTSPOT_DIST
 805 BUILD_OUTPUT
 806 OVERRIDE_SRC_ROOT
 807 ADD_SRC_ROOT
 808 JDK_TOPDIR
 809 NASHORN_TOPDIR
 810 HOTSPOT_TOPDIR
 811 JAXWS_TOPDIR
 812 JAXP_TOPDIR
 813 CORBA_TOPDIR
 814 LANGTOOLS_TOPDIR
 815 JAVA_FLAGS_SMALL
 816 JAVA_FLAGS_BIG
 817 JAVA_FLAGS
 818 BOOT_JDK_BITS
 819 JAVAC_FLAGS
 820 BOOT_JDK_SOURCETARGET
 821 BOOT_JDK
 822 BOOT_TOOLSJAR
 823 BOOT_RTJAR
 824 JAVA_CHECK
 825 JAVAC_CHECK
 826 COOKED_BUILD_NUMBER
 827 COOKED_JDK_UPDATE_VERSION
 828 JDK_VERSION
 829 COPYRIGHT_YEAR
 830 VENDOR_URL_VM_BUG
 831 VENDOR_URL_BUG
 832 VENDOR_URL
 833 COMPANY_NAME
 834 MACOSX_BUNDLE_ID_BASE
 835 MACOSX_BUNDLE_NAME_BASE
 836 JDK_RC_PLATFORM_NAME
 837 PRODUCT_SUFFIX
 838 PRODUCT_NAME
 839 LAUNCHER_NAME
 840 MILESTONE
 841 JDK_BUILD_NUMBER
 842 JDK_UPDATE_VERSION
 843 JDK_MICRO_VERSION
 844 JDK_MINOR_VERSION
 845 JDK_MAJOR_VERSION
 846 USER_RELEASE_SUFFIX
 847 ENABLE_JFR
 848 COMPRESS_JARS
 849 UNLIMITED_CRYPTO
 850 CACERTS_FILE
 851 TEST_IN_BUILD
 852 BUILD_HEADLESS
 853 SUPPORT_HEADFUL
 854 SUPPORT_HEADLESS
 855 BDEPS_FTP
 856 BDEPS_UNZIP
 857 OS_VERSION_MICRO
 858 OS_VERSION_MINOR
 859 OS_VERSION_MAJOR
 860 PKG_CONFIG
 861 CODESIGN
 862 XATTR
 863 DSYMUTIL
 864 IS_GNU_TIME
 865 TIME
 866 STAT
 867 HG
 868 READELF
 869 LDD
 870 ZIP
 871 UNZIP
 872 FIND_DELETE
 873 MAKE
 874 CHECK_TOOLSDIR_MAKE
 875 CHECK_TOOLSDIR_GMAKE
 876 CHECK_MAKE
 877 CHECK_GMAKE
 878 PKGHANDLER
 879 OUTPUT_ROOT
 880 CONF_NAME
 881 SPEC
 882 DEVKIT_LIB_DIR
 883 BUILD_VARIANT_RELEASE
 884 DEBUG_CLASSFILES
 885 FASTDEBUG
 886 VARIANT
 887 DEBUG_LEVEL
 888 MACOSX_UNIVERSAL
 889 INCLUDE_SA
 890 JVM_VARIANT_CORE
 891 JVM_VARIANT_ZEROSHARK
 892 JVM_VARIANT_ZERO
 893 JVM_VARIANT_KERNEL
 894 JVM_VARIANT_MINIMAL1
 895 JVM_VARIANT_CLIENT
 896 JVM_VARIANT_SERVER
 897 JVM_VARIANTS
 898 JVM_INTERPRETER
 899 JDK_VARIANT
 900 SET_OPENJDK
 901 BUILD_LOG_WRAPPER
 902 BUILD_LOG_PREVIOUS
 903 BUILD_LOG
 904 TOPDIR
 905 PATH_SEP
 906 ZERO_ARCHDEF
 907 DEFINE_CROSS_COMPILE_ARCH
 908 LP64
 909 OPENJDK_TARGET_OS_EXPORT_DIR
 910 OPENJDK_TARGET_OS_API_DIR
 911 OPENJDK_TARGET_CPU_JLI_CFLAGS
 912 OPENJDK_TARGET_CPU_OSARCH
 913 OPENJDK_TARGET_CPU_ISADIR
 914 OPENJDK_TARGET_CPU_LIBDIR
 915 OPENJDK_TARGET_CPU_LEGACY_LIB
 916 OPENJDK_TARGET_CPU_LEGACY
 917 REQUIRED_OS_VERSION
 918 REQUIRED_OS_NAME
 919 COMPILE_TYPE
 920 OPENJDK_TARGET_CPU_ENDIAN
 921 OPENJDK_TARGET_CPU_BITS
 922 OPENJDK_TARGET_CPU_ARCH
 923 OPENJDK_TARGET_CPU
 924 OPENJDK_TARGET_OS_ENV
 925 OPENJDK_TARGET_OS_API
 926 OPENJDK_TARGET_OS
 927 OPENJDK_BUILD_CPU_ENDIAN
 928 OPENJDK_BUILD_CPU_BITS
 929 OPENJDK_BUILD_CPU_ARCH
 930 OPENJDK_BUILD_CPU
 931 OPENJDK_BUILD_OS_ENV
 932 OPENJDK_BUILD_OS_API
 933 OPENJDK_BUILD_OS
 934 OPENJDK_BUILD_AUTOCONF_NAME
 935 OPENJDK_TARGET_AUTOCONF_NAME
 936 target_os
 937 target_vendor
 938 target_cpu
 939 target
 940 host_os
 941 host_vendor
 942 host_cpu
 943 host
 944 build_os
 945 build_vendor
 946 build_cpu
 947 build
 948 CPIO
 949 SETFILE
 950 DF
 951 READLINK
 952 CYGPATH
 953 SED
 954 FGREP
 955 EGREP
 956 GREP
 957 AWK
 958 XARGS
 959 WHICH
 960 WC
 961 UNIQ
 962 UNAME
 963 TR
 964 TOUCH
 965 TEE
 966 TAR
 967 TAIL
 968 SORT
 969 SH
 970 RM
 971 PRINTF
 972 NAWK
 973 MV
 974 MKTEMP
 975 MKDIR
 976 LS
 977 LN
 978 HEAD
 979 FIND
 980 FILE
 981 EXPR
 982 ECHO
 983 DIRNAME
 984 DIFF
 985 DATE
 986 CUT
 987 CP
 988 COMM
 989 CMP
 990 CHMOD
 991 CAT
 992 BASH
 993 BASENAME
 994 DATE_WHEN_CONFIGURED
 995 CONFIGURE_COMMAND_LINE
 996 CUSTOM_MAKE_DIR
 997 target_alias
 998 host_alias
 999 build_alias
1000 LIBS
1001 ECHO_T
1002 ECHO_N
1003 ECHO_C
1004 DEFS
1005 mandir
1006 localedir
1007 libdir
1008 psdir
1009 pdfdir
1010 dvidir
1011 htmldir
1012 infodir
1013 docdir
1014 oldincludedir
1015 includedir
1016 localstatedir
1017 sharedstatedir
1018 sysconfdir
1019 datadir
1020 datarootdir
1021 libexecdir
1022 sbindir
1023 bindir
1024 program_transform_name
1025 prefix
1026 exec_prefix
1027 PACKAGE_URL
1028 PACKAGE_BUGREPORT
1029 PACKAGE_STRING
1030 PACKAGE_VERSION
1031 PACKAGE_TARNAME
1032 PACKAGE_NAME
1033 PATH_SEPARATOR
1034 SHELL'
1035 ac_subst_files=''
1036 ac_user_opts='
1037 enable_option_checking
1038 with_custom_make_dir
1039 with_target_bits
1040 enable_openjdk_only
1041 with_jdk_variant
1042 with_jvm_interpreter
1043 with_jvm_variants
1044 enable_debug
1045 with_debug_level
1046 with_devkit
1047 with_sys_root
1048 with_sysroot
1049 with_tools_dir
1050 with_toolchain_path
1051 with_extra_path
1052 with_xcode_path
1053 with_conf_name
1054 with_builddeps_conf
1055 with_builddeps_server
1056 with_builddeps_dir
1057 with_builddeps_group
1058 enable_headful
1059 enable_hotspot_test_in_build
1060 with_cacerts_file
1061 enable_unlimited_crypto
1062 enable_jfr
1063 with_milestone
1064 with_update_version
1065 with_user_release_suffix
1066 with_build_number
1067 with_vendor_name
1068 with_vendor_url
1069 with_vendor_bug_url
1070 with_vendor_vm_bug_url
1071 with_copyright_year
1072 with_boot_jdk
1073 with_boot_jdk_jvmargs
1074 with_add_source_root
1075 with_override_source_root
1076 with_adds_and_overrides
1077 with_override_langtools
1078 with_override_corba
1079 with_override_jaxp
1080 with_override_jaxws
1081 with_override_hotspot
1082 with_override_nashorn
1083 with_override_jdk
1084 with_import_hotspot
1085 with_toolchain_type
1086 with_toolchain_version
1087 with_jtreg
1088 with_extra_cflags
1089 with_extra_cxxflags
1090 with_extra_ldflags
1091 with_extra_asflags
1092 enable_debug_symbols
1093 enable_zip_debug_info
1094 with_native_debug_symbols
1095 enable_macosx_runtime_support
1096 with_x
1097 with_cups
1098 with_cups_include
1099 with_freetype
1100 with_freetype_include
1101 with_freetype_lib
1102 with_freetype_src
1103 enable_freetype_bundling
1104 with_alsa
1105 with_alsa_include
1106 with_alsa_lib
1107 with_fontconfig
1108 with_fontconfig_include
1109 with_giflib
1110 with_zlib
1111 with_stdc__lib
1112 with_msvcr_dll
1113 with_msvcp_dll
1114 with_ucrt_dll_dir
1115 with_dxsdk
1116 with_dxsdk_lib
1117 with_dxsdk_include
1118 with_num_cores
1119 with_memory_size
1120 with_jobs
1121 with_sjavac_server_java
1122 enable_sjavac
1123 enable_precompiled_headers
1124 enable_ccache
1125 with_ccache_dir
1126 '
1127       ac_precious_vars='build_alias
1128 host_alias
1129 target_alias
1130 BASENAME
1131 BASH
1132 CAT
1133 CHMOD
1134 CMP
1135 COMM
1136 CP
1137 CUT
1138 DATE
1139 DIFF
1140 DIRNAME
1141 ECHO
1142 EXPR
1143 FILE
1144 FIND
1145 HEAD
1146 LN
1147 LS
1148 MKDIR
1149 MKTEMP
1150 MV
1151 NAWK
1152 PRINTF
1153 RM
1154 SH
1155 SORT
1156 TAIL
1157 TAR
1158 TEE
1159 TOUCH
1160 TR
1161 UNAME
1162 UNIQ
1163 WC
1164 WHICH
1165 XARGS
1166 AWK
1167 GREP
1168 EGREP
1169 FGREP
1170 SED
1171 CYGPATH
1172 READLINK
1173 DF
1174 SETFILE
1175 CPIO
1176 UNZIP
1177 ZIP
1178 LDD
1179 READELF
1180 HG
1181 STAT
1182 TIME
1183 DSYMUTIL
1184 XATTR
1185 CODESIGN
1186 PKG_CONFIG
1187 CC
1188 CFLAGS
1189 LDFLAGS
1190 LIBS
1191 CPPFLAGS
1192 CXX
1193 CXXFLAGS
1194 CCC
1195 CPP
1196 CXXCPP
1197 AS
1198 AR
1199 OBJC
1200 OBJCFLAGS
1201 LIPO
1202 STRIP
1203 NM
1204 GNM
1205 MCS
1206 OBJCOPY
1207 OBJDUMP
1208 BUILD_CC
1209 BUILD_CXX
1210 BUILD_LD
1211 JTREGEXE
1212 XMKMF
1213 FREETYPE_CFLAGS
1214 FREETYPE_LIBS
1215 ALSA_CFLAGS
1216 ALSA_LIBS
1217 LIBFFI_CFLAGS
1218 LIBFFI_LIBS
1219 CCACHE'
1220 
1221 
1222 # Initialize some variables set by options.
1223 ac_init_help=
1224 ac_init_version=false
1225 ac_unrecognized_opts=
1226 ac_unrecognized_sep=
1227 # The variables have the same names as the options, with
1228 # dashes changed to underlines.
1229 cache_file=/dev/null
1230 exec_prefix=NONE
1231 no_create=
1232 no_recursion=
1233 prefix=NONE
1234 program_prefix=NONE
1235 program_suffix=NONE
1236 program_transform_name=s,x,x,
1237 silent=
1238 site=
1239 srcdir=
1240 verbose=
1241 x_includes=NONE
1242 x_libraries=NONE
1243 
1244 # Installation directory options.
1245 # These are left unexpanded so users can "make install exec_prefix=/foo"
1246 # and all the variables that are supposed to be based on exec_prefix
1247 # by default will actually change.
1248 # Use braces instead of parens because sh, perl, etc. also accept them.
1249 # (The list follows the same order as the GNU Coding Standards.)
1250 bindir='${exec_prefix}/bin'
1251 sbindir='${exec_prefix}/sbin'
1252 libexecdir='${exec_prefix}/libexec'
1253 datarootdir='${prefix}/share'
1254 datadir='${datarootdir}'
1255 sysconfdir='${prefix}/etc'
1256 sharedstatedir='${prefix}/com'
1257 localstatedir='${prefix}/var'
1258 includedir='${prefix}/include'
1259 oldincludedir='/usr/include'
1260 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
1261 infodir='${datarootdir}/info'
1262 htmldir='${docdir}'
1263 dvidir='${docdir}'
1264 pdfdir='${docdir}'
1265 psdir='${docdir}'
1266 libdir='${exec_prefix}/lib'
1267 localedir='${datarootdir}/locale'
1268 mandir='${datarootdir}/man'
1269 
1270 ac_prev=
1271 ac_dashdash=
1272 for ac_option
1273 do
1274   # If the previous option needs an argument, assign it.
1275   if test -n "$ac_prev"; then
1276     eval $ac_prev=\$ac_option
1277     ac_prev=
1278     continue
1279   fi
1280 
1281   case $ac_option in
1282   *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
1283   *=)   ac_optarg= ;;
1284   *)    ac_optarg=yes ;;
1285   esac
1286 
1287   # Accept the important Cygnus configure options, so we can diagnose typos.
1288 
1289   case $ac_dashdash$ac_option in
1290   --)
1291     ac_dashdash=yes ;;
1292 
1293   -bindir | --bindir | --bindi | --bind | --bin | --bi)
1294     ac_prev=bindir ;;
1295   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
1296     bindir=$ac_optarg ;;
1297 
1298   -build | --build | --buil | --bui | --bu)
1299     ac_prev=build_alias ;;
1300   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
1301     build_alias=$ac_optarg ;;
1302 
1303   -cache-file | --cache-file | --cache-fil | --cache-fi \
1304   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
1305     ac_prev=cache_file ;;
1306   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
1307   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
1308     cache_file=$ac_optarg ;;
1309 
1310   --config-cache | -C)
1311     cache_file=config.cache ;;
1312 
1313   -datadir | --datadir | --datadi | --datad)
1314     ac_prev=datadir ;;
1315   -datadir=* | --datadir=* | --datadi=* | --datad=*)
1316     datadir=$ac_optarg ;;
1317 
1318   -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
1319   | --dataroo | --dataro | --datar)
1320     ac_prev=datarootdir ;;
1321   -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
1322   | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
1323     datarootdir=$ac_optarg ;;
1324 
1325   -disable-* | --disable-*)
1326     ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
1327     # Reject names that are not valid shell variable names.
1328     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1329       as_fn_error $? "invalid feature name: $ac_useropt"
1330     ac_useropt_orig=$ac_useropt
1331     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1332     case $ac_user_opts in
1333       *"
1334 "enable_$ac_useropt"
1335 "*) ;;
1336       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
1337          ac_unrecognized_sep=', ';;
1338     esac
1339     eval enable_$ac_useropt=no ;;
1340 
1341   -docdir | --docdir | --docdi | --doc | --do)
1342     ac_prev=docdir ;;
1343   -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
1344     docdir=$ac_optarg ;;
1345 
1346   -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
1347     ac_prev=dvidir ;;
1348   -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
1349     dvidir=$ac_optarg ;;
1350 
1351   -enable-* | --enable-*)
1352     ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
1353     # Reject names that are not valid shell variable names.
1354     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1355       as_fn_error $? "invalid feature name: $ac_useropt"
1356     ac_useropt_orig=$ac_useropt
1357     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1358     case $ac_user_opts in
1359       *"
1360 "enable_$ac_useropt"
1361 "*) ;;
1362       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
1363          ac_unrecognized_sep=', ';;
1364     esac
1365     eval enable_$ac_useropt=\$ac_optarg ;;
1366 
1367   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
1368   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
1369   | --exec | --exe | --ex)
1370     ac_prev=exec_prefix ;;
1371   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
1372   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
1373   | --exec=* | --exe=* | --ex=*)
1374     exec_prefix=$ac_optarg ;;
1375 
1376   -gas | --gas | --ga | --g)
1377     # Obsolete; use --with-gas.
1378     with_gas=yes ;;
1379 
1380   -help | --help | --hel | --he | -h)
1381     ac_init_help=long ;;
1382   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
1383     ac_init_help=recursive ;;
1384   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
1385     ac_init_help=short ;;
1386 
1387   -host | --host | --hos | --ho)
1388     ac_prev=host_alias ;;
1389   -host=* | --host=* | --hos=* | --ho=*)
1390     host_alias=$ac_optarg ;;
1391 
1392   -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
1393     ac_prev=htmldir ;;
1394   -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
1395   | --ht=*)
1396     htmldir=$ac_optarg ;;
1397 
1398   -includedir | --includedir | --includedi | --included | --include \
1399   | --includ | --inclu | --incl | --inc)
1400     ac_prev=includedir ;;
1401   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
1402   | --includ=* | --inclu=* | --incl=* | --inc=*)
1403     includedir=$ac_optarg ;;
1404 
1405   -infodir | --infodir | --infodi | --infod | --info | --inf)
1406     ac_prev=infodir ;;
1407   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
1408     infodir=$ac_optarg ;;
1409 
1410   -libdir | --libdir | --libdi | --libd)
1411     ac_prev=libdir ;;
1412   -libdir=* | --libdir=* | --libdi=* | --libd=*)
1413     libdir=$ac_optarg ;;
1414 
1415   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
1416   | --libexe | --libex | --libe)
1417     ac_prev=libexecdir ;;
1418   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
1419   | --libexe=* | --libex=* | --libe=*)
1420     libexecdir=$ac_optarg ;;
1421 
1422   -localedir | --localedir | --localedi | --localed | --locale)
1423     ac_prev=localedir ;;
1424   -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
1425     localedir=$ac_optarg ;;
1426 
1427   -localstatedir | --localstatedir | --localstatedi | --localstated \
1428   | --localstate | --localstat | --localsta | --localst | --locals)
1429     ac_prev=localstatedir ;;
1430   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
1431   | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
1432     localstatedir=$ac_optarg ;;
1433 
1434   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
1435     ac_prev=mandir ;;
1436   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
1437     mandir=$ac_optarg ;;
1438 
1439   -nfp | --nfp | --nf)
1440     # Obsolete; use --without-fp.
1441     with_fp=no ;;
1442 
1443   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
1444   | --no-cr | --no-c | -n)
1445     no_create=yes ;;
1446 
1447   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
1448   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
1449     no_recursion=yes ;;
1450 
1451   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
1452   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
1453   | --oldin | --oldi | --old | --ol | --o)
1454     ac_prev=oldincludedir ;;
1455   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
1456   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
1457   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
1458     oldincludedir=$ac_optarg ;;
1459 
1460   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
1461     ac_prev=prefix ;;
1462   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
1463     prefix=$ac_optarg ;;
1464 
1465   -program-prefix | --program-prefix | --program-prefi | --program-pref \
1466   | --program-pre | --program-pr | --program-p)
1467     ac_prev=program_prefix ;;
1468   -program-prefix=* | --program-prefix=* | --program-prefi=* \
1469   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
1470     program_prefix=$ac_optarg ;;
1471 
1472   -program-suffix | --program-suffix | --program-suffi | --program-suff \
1473   | --program-suf | --program-su | --program-s)
1474     ac_prev=program_suffix ;;
1475   -program-suffix=* | --program-suffix=* | --program-suffi=* \
1476   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
1477     program_suffix=$ac_optarg ;;
1478 
1479   -program-transform-name | --program-transform-name \
1480   | --program-transform-nam | --program-transform-na \
1481   | --program-transform-n | --program-transform- \
1482   | --program-transform | --program-transfor \
1483   | --program-transfo | --program-transf \
1484   | --program-trans | --program-tran \
1485   | --progr-tra | --program-tr | --program-t)
1486     ac_prev=program_transform_name ;;
1487   -program-transform-name=* | --program-transform-name=* \
1488   | --program-transform-nam=* | --program-transform-na=* \
1489   | --program-transform-n=* | --program-transform-=* \
1490   | --program-transform=* | --program-transfor=* \
1491   | --program-transfo=* | --program-transf=* \
1492   | --program-trans=* | --program-tran=* \
1493   | --progr-tra=* | --program-tr=* | --program-t=*)
1494     program_transform_name=$ac_optarg ;;
1495 
1496   -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
1497     ac_prev=pdfdir ;;
1498   -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
1499     pdfdir=$ac_optarg ;;
1500 
1501   -psdir | --psdir | --psdi | --psd | --ps)
1502     ac_prev=psdir ;;
1503   -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
1504     psdir=$ac_optarg ;;
1505 
1506   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1507   | -silent | --silent | --silen | --sile | --sil)
1508     silent=yes ;;
1509 
1510   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
1511     ac_prev=sbindir ;;
1512   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
1513   | --sbi=* | --sb=*)
1514     sbindir=$ac_optarg ;;
1515 
1516   -sharedstatedir | --sharedstatedir | --sharedstatedi \
1517   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
1518   | --sharedst | --shareds | --shared | --share | --shar \
1519   | --sha | --sh)
1520     ac_prev=sharedstatedir ;;
1521   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
1522   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
1523   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
1524   | --sha=* | --sh=*)
1525     sharedstatedir=$ac_optarg ;;
1526 
1527   -site | --site | --sit)
1528     ac_prev=site ;;
1529   -site=* | --site=* | --sit=*)
1530     site=$ac_optarg ;;
1531 
1532   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
1533     ac_prev=srcdir ;;
1534   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
1535     srcdir=$ac_optarg ;;
1536 
1537   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
1538   | --syscon | --sysco | --sysc | --sys | --sy)
1539     ac_prev=sysconfdir ;;
1540   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
1541   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
1542     sysconfdir=$ac_optarg ;;
1543 
1544   -target | --target | --targe | --targ | --tar | --ta | --t)
1545     ac_prev=target_alias ;;
1546   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
1547     target_alias=$ac_optarg ;;
1548 
1549   -v | -verbose | --verbose | --verbos | --verbo | --verb)
1550     verbose=yes ;;
1551 
1552   -version | --version | --versio | --versi | --vers | -V)
1553     ac_init_version=: ;;
1554 
1555   -with-* | --with-*)
1556     ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1557     # Reject names that are not valid shell variable names.
1558     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1559       as_fn_error $? "invalid package name: $ac_useropt"
1560     ac_useropt_orig=$ac_useropt
1561     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1562     case $ac_user_opts in
1563       *"
1564 "with_$ac_useropt"
1565 "*) ;;
1566       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
1567          ac_unrecognized_sep=', ';;
1568     esac
1569     eval with_$ac_useropt=\$ac_optarg ;;
1570 
1571   -without-* | --without-*)
1572     ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1573     # Reject names that are not valid shell variable names.
1574     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1575       as_fn_error $? "invalid package name: $ac_useropt"
1576     ac_useropt_orig=$ac_useropt
1577     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1578     case $ac_user_opts in
1579       *"
1580 "with_$ac_useropt"
1581 "*) ;;
1582       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
1583          ac_unrecognized_sep=', ';;
1584     esac
1585     eval with_$ac_useropt=no ;;
1586 
1587   --x)
1588     # Obsolete; use --with-x.
1589     with_x=yes ;;
1590 
1591   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
1592   | --x-incl | --x-inc | --x-in | --x-i)
1593     ac_prev=x_includes ;;
1594   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
1595   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
1596     x_includes=$ac_optarg ;;
1597 
1598   -x-libraries | --x-libraries | --x-librarie | --x-librari \
1599   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
1600     ac_prev=x_libraries ;;
1601   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
1602   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1603     x_libraries=$ac_optarg ;;
1604 
1605   -*) as_fn_error $? "unrecognized option: \`$ac_option'
1606 Try \`$0 --help' for more information"
1607     ;;
1608 
1609   *=*)
1610     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1611     # Reject names that are not valid shell variable names.
1612     case $ac_envvar in #(
1613       '' | [0-9]* | *[!_$as_cr_alnum]* )
1614       as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1615     esac
1616     eval $ac_envvar=\$ac_optarg
1617     export $ac_envvar ;;
1618 
1619   *)
1620     # FIXME: should be removed in autoconf 3.0.
1621     $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1622     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1623       $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1624     : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1625     ;;
1626 
1627   esac
1628 done
1629 
1630 if test -n "$ac_prev"; then
1631   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1632   as_fn_error $? "missing argument to $ac_option"
1633 fi
1634 
1635 if test -n "$ac_unrecognized_opts"; then
1636   case $enable_option_checking in
1637     no) ;;
1638     fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1639     *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1640   esac
1641 fi
1642 
1643 # Check all directory arguments for consistency.
1644 for ac_var in   exec_prefix prefix bindir sbindir libexecdir datarootdir \
1645                 datadir sysconfdir sharedstatedir localstatedir includedir \
1646                 oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
1647                 libdir localedir mandir
1648 do
1649   eval ac_val=\$$ac_var
1650   # Remove trailing slashes.
1651   case $ac_val in
1652     */ )
1653       ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
1654       eval $ac_var=\$ac_val;;
1655   esac
1656   # Be sure to have absolute directory names.
1657   case $ac_val in
1658     [\\/$]* | ?:[\\/]* )  continue;;
1659     NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1660   esac
1661   as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1662 done
1663 
1664 # There might be people who depend on the old broken behavior: `$host'
1665 # used to hold the argument of --host etc.
1666 # FIXME: To remove some day.
1667 build=$build_alias
1668 host=$host_alias
1669 target=$target_alias
1670 
1671 # FIXME: To remove some day.
1672 if test "x$host_alias" != x; then
1673   if test "x$build_alias" = x; then
1674     cross_compiling=maybe
1675   elif test "x$build_alias" != "x$host_alias"; then
1676     cross_compiling=yes
1677   fi
1678 fi
1679 
1680 ac_tool_prefix=
1681 test -n "$host_alias" && ac_tool_prefix=$host_alias-
1682 
1683 test "$silent" = yes && exec 6>/dev/null
1684 
1685 
1686 ac_pwd=`pwd` && test -n "$ac_pwd" &&
1687 ac_ls_di=`ls -di .` &&
1688 ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1689   as_fn_error $? "working directory cannot be determined"
1690 test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1691   as_fn_error $? "pwd does not report name of working directory"
1692 
1693 
1694 # Find the source files, if location was not specified.
1695 if test -z "$srcdir"; then
1696   ac_srcdir_defaulted=yes
1697   # Try the directory containing this script, then the parent directory.
1698   ac_confdir=`$as_dirname -- "$as_myself" ||
1699 $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1700          X"$as_myself" : 'X\(//\)[^/]' \| \
1701          X"$as_myself" : 'X\(//\)$' \| \
1702          X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
1703 $as_echo X"$as_myself" |
1704     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
1705             s//\1/
1706             q
1707           }
1708           /^X\(\/\/\)[^/].*/{
1709             s//\1/
1710             q
1711           }
1712           /^X\(\/\/\)$/{
1713             s//\1/
1714             q
1715           }
1716           /^X\(\/\).*/{
1717             s//\1/
1718             q
1719           }
1720           s/.*/./; q'`
1721   srcdir=$ac_confdir
1722   if test ! -r "$srcdir/$ac_unique_file"; then
1723     srcdir=..
1724   fi
1725 else
1726   ac_srcdir_defaulted=no
1727 fi
1728 if test ! -r "$srcdir/$ac_unique_file"; then
1729   test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1730   as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1731 fi
1732 ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1733 ac_abs_confdir=`(
1734         cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1735         pwd)`
1736 # When building in place, set srcdir=.
1737 if test "$ac_abs_confdir" = "$ac_pwd"; then
1738   srcdir=.
1739 fi
1740 # Remove unnecessary trailing slashes from srcdir.
1741 # Double slashes in file names in object file debugging info
1742 # mess up M-x gdb in Emacs.
1743 case $srcdir in
1744 */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
1745 esac
1746 for ac_var in $ac_precious_vars; do
1747   eval ac_env_${ac_var}_set=\${${ac_var}+set}
1748   eval ac_env_${ac_var}_value=\$${ac_var}
1749   eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
1750   eval ac_cv_env_${ac_var}_value=\$${ac_var}
1751 done
1752 
1753 #
1754 # Report the --help message.
1755 #
1756 if test "$ac_init_help" = "long"; then
1757   # Omit some internal or obsolete options to make the list less imposing.
1758   # This message is too long to be a string in the A/UX 3.1 sh.
1759   cat <<_ACEOF
1760 \`configure' configures OpenJDK jdk8 to adapt to many kinds of systems.
1761 
1762 Usage: $0 [OPTION]... [VAR=VALUE]...
1763 
1764 To assign environment variables (e.g., CC, CFLAGS...), specify them as
1765 VAR=VALUE.  See below for descriptions of some of the useful variables.
1766 
1767 Defaults for the options are specified in brackets.
1768 
1769 Configuration:
1770   -h, --help              display this help and exit
1771       --help=short        display options specific to this package
1772       --help=recursive    display the short help of all the included packages
1773   -V, --version           display version information and exit
1774   -q, --quiet, --silent   do not print \`checking ...' messages
1775       --cache-file=FILE   cache test results in FILE [disabled]
1776   -C, --config-cache      alias for \`--cache-file=config.cache'
1777   -n, --no-create         do not create output files
1778       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
1779 
1780 Installation directories:
1781   --prefix=PREFIX         install architecture-independent files in PREFIX
1782                           [$ac_default_prefix]
1783   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
1784                           [PREFIX]
1785 
1786 By default, \`make install' will install all the files in
1787 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
1788 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
1789 for instance \`--prefix=\$HOME'.
1790 
1791 For better control, use the options below.
1792 
1793 Fine tuning of the installation directories:
1794   --bindir=DIR            user executables [EPREFIX/bin]
1795   --sbindir=DIR           system admin executables [EPREFIX/sbin]
1796   --libexecdir=DIR        program executables [EPREFIX/libexec]
1797   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
1798   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
1799   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
1800   --libdir=DIR            object code libraries [EPREFIX/lib]
1801   --includedir=DIR        C header files [PREFIX/include]
1802   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
1803   --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
1804   --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
1805   --infodir=DIR           info documentation [DATAROOTDIR/info]
1806   --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
1807   --mandir=DIR            man documentation [DATAROOTDIR/man]
1808   --docdir=DIR            documentation root [DATAROOTDIR/doc/openjdk]
1809   --htmldir=DIR           html documentation [DOCDIR]
1810   --dvidir=DIR            dvi documentation [DOCDIR]
1811   --pdfdir=DIR            pdf documentation [DOCDIR]
1812   --psdir=DIR             ps documentation [DOCDIR]
1813 _ACEOF
1814 
1815   cat <<\_ACEOF
1816 
1817 X features:
1818   --x-includes=DIR    X include files are in DIR
1819   --x-libraries=DIR   X library files are in DIR
1820 
1821 System types:
1822   --build=BUILD     configure for building on BUILD [guessed]
1823   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
1824   --target=TARGET   configure for building compilers for TARGET [HOST]
1825 _ACEOF
1826 fi
1827 
1828 if test -n "$ac_init_help"; then
1829   case $ac_init_help in
1830      short | recursive ) echo "Configuration of OpenJDK jdk8:";;
1831    esac
1832   cat <<\_ACEOF
1833 
1834 Optional Features:
1835   --disable-option-checking  ignore unrecognized --enable/--with options
1836   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1837   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
1838   --enable-openjdk-only   suppress building custom source even if present
1839                           [disabled]
1840   --enable-debug          set the debug level to fastdebug (shorthand for
1841                           --with-debug-level=fastdebug) [disabled]
1842   --disable-headful       disable building headful support (graphical UI
1843                           support) [enabled]
1844   --enable-hotspot-test-in-build
1845                           run the Queens test after Hotspot build [disabled]
1846   --enable-unlimited-crypto
1847                           Enable unlimited crypto policy [disabled]
1848   --disable-jfr           Disable Java Flight Recorder support [enabled]
1849   --disable-debug-symbols disable generation of debug symbols [enabled]
1850   --disable-zip-debug-info
1851                           disable zipping of debug-info files [enabled]
1852   --enable-macosx-runtime-support
1853                           Deprecated. Option is kept for backwards
1854                           compatibility and is ignored
1855   --disable-freetype-bundling
1856                           disable bundling of the freetype library with the
1857                           build result [enabled on Windows or when using
1858                           --with-freetype, disabled otherwise]
1859   --enable-sjavac         use sjavac to do fast incremental compiles
1860                           [disabled]
1861   --disable-precompiled-headers
1862                           disable using precompiled headers when compiling C++
1863                           [enabled]
1864   --enable-ccache         enable using ccache to speed up recompilations
1865                           [disabled]
1866 
1867 Optional Packages:
1868   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1869   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
1870   --with-custom-make-dir  use this directory for custom build/make files
1871   --with-target-bits      build 32-bit or 64-bit binaries (for platforms that
1872                           support it), e.g. --with-target-bits=32 [guessed]
1873   --with-jdk-variant      JDK variant to build (normal) [normal]
1874   --with-jvm-interpreter  JVM interpreter to build (template, cpp) [template]
1875   --with-jvm-variants     JVM variants (separated by commas) to build (server,
1876                           client, minimal1, kernel, zero, zeroshark, core)
1877                           [server]
1878   --with-debug-level      set the debug level (release, fastdebug, slowdebug)
1879                           [release]
1880   --with-devkit           use this devkit for compilers, tools and resources
1881   --with-sys-root         alias for --with-sysroot for backwards compatability
1882   --with-sysroot          use this directory as sysroot)
1883   --with-tools-dir        alias for --with-toolchain-path for backwards
1884                           compatibility
1885   --with-toolchain-path   prepend these directories when searching for
1886                           toolchain binaries (compilers etc)
1887   --with-extra-path       prepend these directories to the default path
1888   --with-xcode-path       explicit path to Xcode 4 (generally for building on
1889                           10.9 and later)
1890   --with-conf-name        use this as the name of the configuration [generated
1891                           from important configuration options]
1892   --with-builddeps-conf   use this configuration file for the builddeps
1893   --with-builddeps-server download and use build dependencies from this server
1894                           url
1895   --with-builddeps-dir    store downloaded build dependencies here
1896                           [/localhome/builddeps]
1897   --with-builddeps-group  chgrp the downloaded build dependencies to this
1898                           group
1899   --with-cacerts-file     specify alternative cacerts file
1900   --with-milestone        Set milestone value for build [internal]
1901   --with-update-version   Set update version value for build [b00]
1902   --with-user-release-suffix
1903                           Add a custom string to the version string if build
1904                           number isn't set.[username_builddateb00]
1905   --with-build-number     Set build number value for build [b00]
1906   --with-vendor-name      Set vendor name. Among others, used to set the
1907                           'java.vendor' and 'java.vm.vendor' system
1908                           properties. [not specified]
1909   --with-vendor-url       Set the 'java.vendor.url' system property [not
1910                           specified]
1911   --with-vendor-bug-url   Set the 'java.vendor.url.bug' system property [not
1912                           specified]
1913   --with-vendor-vm-bug-url
1914                           Sets the bug URL which will be displayed when the VM
1915                           crashes [not specified]
1916   --with-copyright-year   Set copyright year value for build [current year]
1917   --with-boot-jdk         path to Boot JDK (used to bootstrap build) [probed]
1918   --with-boot-jdk-jvmargs specify JVM arguments to be passed to all
1919                           invocations of the Boot JDK, overriding the default
1920                           values, e.g --with-boot-jdk-jvmargs="-Xmx8G
1921                           -enableassertions"
1922   --with-add-source-root  for each and every source directory, look in this
1923                           additional source root for the same directory; if it
1924                           exists and have files in it, include it in the build
1925   --with-override-source-root
1926                           for each and every source directory, look in this
1927                           override source root for the same directory; if it
1928                           exists, use that directory instead and ignore the
1929                           directory in the original source root
1930   --with-adds-and-overrides
1931                           use the subdirs 'adds' and 'overrides' in the
1932                           specified directory as add-source-root and
1933                           override-source-root
1934   --with-override-langtools
1935                           use this langtools dir for the build
1936   --with-override-corba   use this corba dir for the build
1937   --with-override-jaxp    use this jaxp dir for the build
1938   --with-override-jaxws   use this jaxws dir for the build
1939   --with-override-hotspot use this hotspot dir for the build
1940   --with-override-nashorn use this nashorn dir for the build
1941   --with-override-jdk     use this jdk dir for the build
1942   --with-import-hotspot   import hotspot binaries from this jdk image or
1943                           hotspot build dist dir instead of building from
1944                           source
1945   --with-toolchain-type   the toolchain type (or family) to use, use '--help'
1946                           to show possible values [platform dependent]
1947   --with-toolchain-version
1948                           the version of the toolchain to look for, use
1949                           '--help' to show possible values [platform
1950                           dependent]
1951   --with-jtreg            Regression Test Harness [probed]
1952   --with-extra-cflags     extra flags to be used when compiling jdk c-files
1953   --with-extra-cxxflags   extra flags to be used when compiling jdk c++-files
1954   --with-extra-ldflags    extra flags to be used when linking jdk
1955   --with-extra-asflags    extra flags to be passed to the assembler
1956   --with-native-debug-symbols
1957                           set the native debug symbol configuration (none,
1958                           internal, external, zipped) [varying]
1959   --with-x                use the X Window System
1960   --with-cups             specify prefix directory for the cups package
1961                           (expecting the headers under PATH/include)
1962   --with-cups-include     specify directory for the cups include files
1963   --with-freetype         specify prefix directory for the freetype package
1964                           (expecting the libraries under PATH/lib and the
1965                           headers under PATH/include)
1966   --with-freetype-include specify directory for the freetype include files
1967   --with-freetype-lib     specify directory for the freetype library
1968   --with-freetype-src     specify directory with freetype sources to
1969                           automatically build the library (experimental,
1970                           Windows-only)
1971   --with-alsa             specify prefix directory for the alsa package
1972                           (expecting the libraries under PATH/lib and the
1973                           headers under PATH/include)
1974   --with-alsa-include     specify directory for the alsa include files
1975   --with-alsa-lib         specify directory for the alsa library
1976   --with-fontconfig       specify prefix directory for the fontconfig package
1977                           (expecting the headers under PATH/include)
1978   --with-fontconfig-include
1979                           specify directory for the fontconfig include files
1980   --with-giflib           use giflib from build system or OpenJDK source
1981                           (system, bundled) [bundled]
1982   --with-zlib             use zlib from build system or OpenJDK source
1983                           (system, bundled) [bundled]
1984   --with-stdc++lib=<static>,<dynamic>,<default>
1985                           force linking of the C++ runtime on Linux to either
1986                           static or dynamic, default is static with dynamic as
1987                           fallback
1988   --with-msvcr-dll        path to microsoft C runtime dll (msvcr*.dll)
1989                           (Windows only) [probed]
1990   --with-msvcp-dll        path to microsoft C++ runtime dll (msvcp*.dll)
1991                           (Windows only) [probed]
1992   --with-ucrt-dll-dir     path to Microsoft Windows Kit UCRT DLL dir (Windows
1993                           only) [probed]
1994   --with-dxsdk            Deprecated. Option is kept for backwards
1995                           compatibility and is ignored
1996   --with-dxsdk-lib        Deprecated. Option is kept for backwards
1997                           compatibility and is ignored
1998   --with-dxsdk-include    Deprecated. Option is kept for backwards
1999                           compatibility and is ignored
2000   --with-num-cores        number of cores in the build system, e.g.
2001                           --with-num-cores=8 [probed]
2002   --with-memory-size      memory (in MB) available in the build system, e.g.
2003                           --with-memory-size=1024 [probed]
2004   --with-jobs             number of parallel jobs to let make run [calculated
2005                           based on cores and memory]
2006   --with-sjavac-server-java
2007                           use this java binary for running the sjavac
2008                           background server [Boot JDK java]
2009   --with-ccache-dir       where to store ccache files [~/.ccache]
2010 
2011 Some influential environment variables:
2012   BASENAME    Override default value for BASENAME
2013   BASH        Override default value for BASH
2014   CAT         Override default value for CAT
2015   CHMOD       Override default value for CHMOD
2016   CMP         Override default value for CMP
2017   COMM        Override default value for COMM
2018   CP          Override default value for CP
2019   CUT         Override default value for CUT
2020   DATE        Override default value for DATE
2021   DIFF        Override default value for DIFF
2022   DIRNAME     Override default value for DIRNAME
2023   ECHO        Override default value for ECHO
2024   EXPR        Override default value for EXPR
2025   FILE        Override default value for FILE
2026   FIND        Override default value for FIND
2027   HEAD        Override default value for HEAD
2028   LN          Override default value for LN
2029   LS          Override default value for LS
2030   MKDIR       Override default value for MKDIR
2031   MKTEMP      Override default value for MKTEMP
2032   MV          Override default value for MV
2033   NAWK        Override default value for NAWK
2034   PRINTF      Override default value for PRINTF
2035   RM          Override default value for RM
2036   SH          Override default value for SH
2037   SORT        Override default value for SORT
2038   TAIL        Override default value for TAIL
2039   TAR         Override default value for TAR
2040   TEE         Override default value for TEE
2041   TOUCH       Override default value for TOUCH
2042   TR          Override default value for TR
2043   UNAME       Override default value for UNAME
2044   UNIQ        Override default value for UNIQ
2045   WC          Override default value for WC
2046   WHICH       Override default value for WHICH
2047   XARGS       Override default value for XARGS
2048   AWK         Override default value for AWK
2049   GREP        Override default value for GREP
2050   EGREP       Override default value for EGREP
2051   FGREP       Override default value for FGREP
2052   SED         Override default value for SED
2053   CYGPATH     Override default value for CYGPATH
2054   READLINK    Override default value for READLINK
2055   DF          Override default value for DF
2056   SETFILE     Override default value for SETFILE
2057   CPIO        Override default value for CPIO
2058   UNZIP       Override default value for UNZIP
2059   ZIP         Override default value for ZIP
2060   LDD         Override default value for LDD
2061   READELF     Override default value for READELF
2062   HG          Override default value for HG
2063   STAT        Override default value for STAT
2064   TIME        Override default value for TIME
2065   DSYMUTIL    Override default value for DSYMUTIL
2066   XATTR       Override default value for XATTR
2067   CODESIGN    Override default value for CODESIGN
2068   PKG_CONFIG  path to pkg-config utility
2069   CC          C compiler command
2070   CFLAGS      C compiler flags
2071   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
2072               nonstandard directory <lib dir>
2073   LIBS        libraries to pass to the linker, e.g. -l<library>
2074   CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
2075               you have headers in a nonstandard directory <include dir>
2076   CXX         C++ compiler command
2077   CXXFLAGS    C++ compiler flags
2078   CPP         C preprocessor
2079   CXXCPP      C++ preprocessor
2080   AS          Override default value for AS
2081   AR          Override default value for AR
2082   OBJC        Objective C compiler command
2083   OBJCFLAGS   Objective C compiler flags
2084   LIPO        Override default value for LIPO
2085   STRIP       Override default value for STRIP
2086   NM          Override default value for NM
2087   GNM         Override default value for GNM
2088   MCS         Override default value for MCS
2089   OBJCOPY     Override default value for OBJCOPY
2090   OBJDUMP     Override default value for OBJDUMP
2091   BUILD_CC    Override default value for BUILD_CC
2092   BUILD_CXX   Override default value for BUILD_CXX
2093   BUILD_LD    Override default value for BUILD_LD
2094   JTREGEXE    Override default value for JTREGEXE
2095   XMKMF       Path to xmkmf, Makefile generator for X Window System
2096   FREETYPE_CFLAGS
2097               C compiler flags for FREETYPE, overriding pkg-config
2098   FREETYPE_LIBS
2099               linker flags for FREETYPE, overriding pkg-config
2100   ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
2101   ALSA_LIBS   linker flags for ALSA, overriding pkg-config
2102   LIBFFI_CFLAGS
2103               C compiler flags for LIBFFI, overriding pkg-config
2104   LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
2105   CCACHE      Override default value for CCACHE
2106 
2107 Use these variables to override the choices made by `configure' or to help
2108 it to find libraries and programs with nonstandard names/locations.
2109 
2110 Report bugs to <build-dev@openjdk.java.net>.
2111 OpenJDK home page: <http://openjdk.java.net>.
2112 _ACEOF
2113 ac_status=$?
2114 fi
2115 
2116 if test "$ac_init_help" = "recursive"; then
2117   # If there are subdirs, report their specific --help.
2118   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
2119     test -d "$ac_dir" ||
2120       { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
2121       continue
2122     ac_builddir=.
2123 
2124 case "$ac_dir" in
2125 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
2126 *)
2127   ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
2128   # A ".." for each directory in $ac_dir_suffix.
2129   ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
2130   case $ac_top_builddir_sub in
2131   "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
2132   *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
2133   esac ;;
2134 esac
2135 ac_abs_top_builddir=$ac_pwd
2136 ac_abs_builddir=$ac_pwd$ac_dir_suffix
2137 # for backward compatibility:
2138 ac_top_builddir=$ac_top_build_prefix
2139 
2140 case $srcdir in
2141   .)  # We are building in place.
2142     ac_srcdir=.
2143     ac_top_srcdir=$ac_top_builddir_sub
2144     ac_abs_top_srcdir=$ac_pwd ;;
2145   [\\/]* | ?:[\\/]* )  # Absolute name.
2146     ac_srcdir=$srcdir$ac_dir_suffix;
2147     ac_top_srcdir=$srcdir
2148     ac_abs_top_srcdir=$srcdir ;;
2149   *) # Relative name.
2150     ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
2151     ac_top_srcdir=$ac_top_build_prefix$srcdir
2152     ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
2153 esac
2154 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
2155 
2156     cd "$ac_dir" || { ac_status=$?; continue; }
2157     # Check for guested configure.
2158     if test -f "$ac_srcdir/configure.gnu"; then
2159       echo &&
2160       $SHELL "$ac_srcdir/configure.gnu" --help=recursive
2161     elif test -f "$ac_srcdir/configure"; then
2162       echo &&
2163       $SHELL "$ac_srcdir/configure" --help=recursive
2164     else
2165       $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
2166     fi || ac_status=$?
2167     cd "$ac_pwd" || { ac_status=$?; break; }
2168   done
2169 fi
2170 
2171 test -n "$ac_init_help" && exit $ac_status
2172 if $ac_init_version; then
2173   cat <<\_ACEOF
2174 OpenJDK configure jdk8
2175 generated by GNU Autoconf 2.69
2176 
2177 Copyright (C) 2012 Free Software Foundation, Inc.
2178 This configure script is free software; the Free Software Foundation
2179 gives unlimited permission to copy, distribute and modify it.
2180 _ACEOF
2181   exit
2182 fi
2183 
2184 ## ------------------------ ##
2185 ## Autoconf initialization. ##
2186 ## ------------------------ ##
2187 
2188 # ac_fn_c_try_compile LINENO
2189 # --------------------------
2190 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2191 ac_fn_c_try_compile ()
2192 {
2193   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2194   rm -f conftest.$ac_objext
2195   if { { ac_try="$ac_compile"
2196 case "(($ac_try" in
2197   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2198   *) ac_try_echo=$ac_try;;
2199 esac
2200 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2201 $as_echo "$ac_try_echo"; } >&5
2202   (eval "$ac_compile") 2>conftest.err
2203   ac_status=$?
2204   if test -s conftest.err; then
2205     grep -v '^ *+' conftest.err >conftest.er1
2206     cat conftest.er1 >&5
2207     mv -f conftest.er1 conftest.err
2208   fi
2209   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2210   test $ac_status = 0; } && {
2211          test -z "$ac_c_werror_flag" ||
2212          test ! -s conftest.err
2213        } && test -s conftest.$ac_objext; then :
2214   ac_retval=0
2215 else
2216   $as_echo "$as_me: failed program was:" >&5
2217 sed 's/^/| /' conftest.$ac_ext >&5
2218 
2219         ac_retval=1
2220 fi
2221   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2222   as_fn_set_status $ac_retval
2223 
2224 } # ac_fn_c_try_compile
2225 
2226 # ac_fn_cxx_try_compile LINENO
2227 # ----------------------------
2228 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2229 ac_fn_cxx_try_compile ()
2230 {
2231   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2232   rm -f conftest.$ac_objext
2233   if { { ac_try="$ac_compile"
2234 case "(($ac_try" in
2235   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2236   *) ac_try_echo=$ac_try;;
2237 esac
2238 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2239 $as_echo "$ac_try_echo"; } >&5
2240   (eval "$ac_compile") 2>conftest.err
2241   ac_status=$?
2242   if test -s conftest.err; then
2243     grep -v '^ *+' conftest.err >conftest.er1
2244     cat conftest.er1 >&5
2245     mv -f conftest.er1 conftest.err
2246   fi
2247   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2248   test $ac_status = 0; } && {
2249          test -z "$ac_cxx_werror_flag" ||
2250          test ! -s conftest.err
2251        } && test -s conftest.$ac_objext; then :
2252   ac_retval=0
2253 else
2254   $as_echo "$as_me: failed program was:" >&5
2255 sed 's/^/| /' conftest.$ac_ext >&5
2256 
2257         ac_retval=1
2258 fi
2259   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2260   as_fn_set_status $ac_retval
2261 
2262 } # ac_fn_cxx_try_compile
2263 
2264 # ac_fn_c_try_cpp LINENO
2265 # ----------------------
2266 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2267 ac_fn_c_try_cpp ()
2268 {
2269   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2270   if { { ac_try="$ac_cpp conftest.$ac_ext"
2271 case "(($ac_try" in
2272   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2273   *) ac_try_echo=$ac_try;;
2274 esac
2275 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2276 $as_echo "$ac_try_echo"; } >&5
2277   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2278   ac_status=$?
2279   if test -s conftest.err; then
2280     grep -v '^ *+' conftest.err >conftest.er1
2281     cat conftest.er1 >&5
2282     mv -f conftest.er1 conftest.err
2283   fi
2284   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2285   test $ac_status = 0; } > conftest.i && {
2286          test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
2287          test ! -s conftest.err
2288        }; then :
2289   ac_retval=0
2290 else
2291   $as_echo "$as_me: failed program was:" >&5
2292 sed 's/^/| /' conftest.$ac_ext >&5
2293 
2294     ac_retval=1
2295 fi
2296   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2297   as_fn_set_status $ac_retval
2298 
2299 } # ac_fn_c_try_cpp
2300 
2301 # ac_fn_cxx_try_cpp LINENO
2302 # ------------------------
2303 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2304 ac_fn_cxx_try_cpp ()
2305 {
2306   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2307   if { { ac_try="$ac_cpp conftest.$ac_ext"
2308 case "(($ac_try" in
2309   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2310   *) ac_try_echo=$ac_try;;
2311 esac
2312 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2313 $as_echo "$ac_try_echo"; } >&5
2314   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2315   ac_status=$?
2316   if test -s conftest.err; then
2317     grep -v '^ *+' conftest.err >conftest.er1
2318     cat conftest.er1 >&5
2319     mv -f conftest.er1 conftest.err
2320   fi
2321   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2322   test $ac_status = 0; } > conftest.i && {
2323          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2324          test ! -s conftest.err
2325        }; then :
2326   ac_retval=0
2327 else
2328   $as_echo "$as_me: failed program was:" >&5
2329 sed 's/^/| /' conftest.$ac_ext >&5
2330 
2331     ac_retval=1
2332 fi
2333   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2334   as_fn_set_status $ac_retval
2335 
2336 } # ac_fn_cxx_try_cpp
2337 
2338 # ac_fn_objc_try_compile LINENO
2339 # -----------------------------
2340 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2341 ac_fn_objc_try_compile ()
2342 {
2343   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2344   rm -f conftest.$ac_objext
2345   if { { ac_try="$ac_compile"
2346 case "(($ac_try" in
2347   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2348   *) ac_try_echo=$ac_try;;
2349 esac
2350 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2351 $as_echo "$ac_try_echo"; } >&5
2352   (eval "$ac_compile") 2>conftest.err
2353   ac_status=$?
2354   if test -s conftest.err; then
2355     grep -v '^ *+' conftest.err >conftest.er1
2356     cat conftest.er1 >&5
2357     mv -f conftest.er1 conftest.err
2358   fi
2359   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2360   test $ac_status = 0; } && {
2361          test -z "$ac_objc_werror_flag" ||
2362          test ! -s conftest.err
2363        } && test -s conftest.$ac_objext; then :
2364   ac_retval=0
2365 else
2366   $as_echo "$as_me: failed program was:" >&5
2367 sed 's/^/| /' conftest.$ac_ext >&5
2368 
2369         ac_retval=1
2370 fi
2371   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2372   as_fn_set_status $ac_retval
2373 
2374 } # ac_fn_objc_try_compile
2375 
2376 # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2377 # ---------------------------------------------------------
2378 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2379 # the include files in INCLUDES and setting the cache variable VAR
2380 # accordingly.
2381 ac_fn_cxx_check_header_mongrel ()
2382 {
2383   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2384   if eval \${$3+:} false; then :
2385   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2386 $as_echo_n "checking for $2... " >&6; }
2387 if eval \${$3+:} false; then :
2388   $as_echo_n "(cached) " >&6
2389 fi
2390 eval ac_res=\$$3
2391                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2392 $as_echo "$ac_res" >&6; }
2393 else
2394   # Is the header compilable?
2395 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2396 $as_echo_n "checking $2 usability... " >&6; }
2397 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2398 /* end confdefs.h.  */
2399 $4
2400 #include <$2>
2401 _ACEOF
2402 if ac_fn_cxx_try_compile "$LINENO"; then :
2403   ac_header_compiler=yes
2404 else
2405   ac_header_compiler=no
2406 fi
2407 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2408 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2409 $as_echo "$ac_header_compiler" >&6; }
2410 
2411 # Is the header present?
2412 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2413 $as_echo_n "checking $2 presence... " >&6; }
2414 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2415 /* end confdefs.h.  */
2416 #include <$2>
2417 _ACEOF
2418 if ac_fn_cxx_try_cpp "$LINENO"; then :
2419   ac_header_preproc=yes
2420 else
2421   ac_header_preproc=no
2422 fi
2423 rm -f conftest.err conftest.i conftest.$ac_ext
2424 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2425 $as_echo "$ac_header_preproc" >&6; }
2426 
2427 # So?  What about this header?
2428 case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2429   yes:no: )
2430     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2431 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2432     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2433 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2434     ;;
2435   no:yes:* )
2436     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2437 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2438     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
2439 $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
2440     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2441 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2442     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
2443 $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
2444     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2445 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2446 ( $as_echo "## ----------------------------------------- ##
2447 ## Report this to build-dev@openjdk.java.net ##
2448 ## ----------------------------------------- ##"
2449      ) | sed "s/^/$as_me: WARNING:     /" >&2
2450     ;;
2451 esac
2452   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2453 $as_echo_n "checking for $2... " >&6; }
2454 if eval \${$3+:} false; then :
2455   $as_echo_n "(cached) " >&6
2456 else
2457   eval "$3=\$ac_header_compiler"
2458 fi
2459 eval ac_res=\$$3
2460                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2461 $as_echo "$ac_res" >&6; }
2462 fi
2463   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2464 
2465 } # ac_fn_cxx_check_header_mongrel
2466 
2467 # ac_fn_cxx_try_run LINENO
2468 # ------------------------
2469 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2470 # that executables *can* be run.
2471 ac_fn_cxx_try_run ()
2472 {
2473   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2474   if { { ac_try="$ac_link"
2475 case "(($ac_try" in
2476   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2477   *) ac_try_echo=$ac_try;;
2478 esac
2479 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2480 $as_echo "$ac_try_echo"; } >&5
2481   (eval "$ac_link") 2>&5
2482   ac_status=$?
2483   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2484   test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2485   { { case "(($ac_try" in
2486   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2487   *) ac_try_echo=$ac_try;;
2488 esac
2489 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2490 $as_echo "$ac_try_echo"; } >&5
2491   (eval "$ac_try") 2>&5
2492   ac_status=$?
2493   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2494   test $ac_status = 0; }; }; then :
2495   ac_retval=0
2496 else
2497   $as_echo "$as_me: program exited with status $ac_status" >&5
2498        $as_echo "$as_me: failed program was:" >&5
2499 sed 's/^/| /' conftest.$ac_ext >&5
2500 
2501        ac_retval=$ac_status
2502 fi
2503   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2504   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2505   as_fn_set_status $ac_retval
2506 
2507 } # ac_fn_cxx_try_run
2508 
2509 # ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
2510 # ---------------------------------------------------------
2511 # Tests whether HEADER exists and can be compiled using the include files in
2512 # INCLUDES, setting the cache variable VAR accordingly.
2513 ac_fn_cxx_check_header_compile ()
2514 {
2515   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2516   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2517 $as_echo_n "checking for $2... " >&6; }
2518 if eval \${$3+:} false; then :
2519   $as_echo_n "(cached) " >&6
2520 else
2521   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2522 /* end confdefs.h.  */
2523 $4
2524 #include <$2>
2525 _ACEOF
2526 if ac_fn_cxx_try_compile "$LINENO"; then :
2527   eval "$3=yes"
2528 else
2529   eval "$3=no"
2530 fi
2531 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2532 fi
2533 eval ac_res=\$$3
2534                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2535 $as_echo "$ac_res" >&6; }
2536   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2537 
2538 } # ac_fn_cxx_check_header_compile
2539 
2540 # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
2541 # ----------------------------------------------
2542 # Tries to find the compile-time value of EXPR in a program that includes
2543 # INCLUDES, setting VAR accordingly. Returns whether the value could be
2544 # computed
2545 ac_fn_cxx_compute_int ()
2546 {
2547   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2548   if test "$cross_compiling" = yes; then
2549     # Depending upon the size, compute the lo and hi bounds.
2550 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2551 /* end confdefs.h.  */
2552 $4
2553 int
2554 main ()
2555 {
2556 static int test_array [1 - 2 * !(($2) >= 0)];
2557 test_array [0] = 0;
2558 return test_array [0];
2559 
2560   ;
2561   return 0;
2562 }
2563 _ACEOF
2564 if ac_fn_cxx_try_compile "$LINENO"; then :
2565   ac_lo=0 ac_mid=0
2566   while :; do
2567     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2568 /* end confdefs.h.  */
2569 $4
2570 int
2571 main ()
2572 {
2573 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2574 test_array [0] = 0;
2575 return test_array [0];
2576 
2577   ;
2578   return 0;
2579 }
2580 _ACEOF
2581 if ac_fn_cxx_try_compile "$LINENO"; then :
2582   ac_hi=$ac_mid; break
2583 else
2584   as_fn_arith $ac_mid + 1 && ac_lo=$as_val
2585                         if test $ac_lo -le $ac_mid; then
2586                           ac_lo= ac_hi=
2587                           break
2588                         fi
2589                         as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
2590 fi
2591 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2592   done
2593 else
2594   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2595 /* end confdefs.h.  */
2596 $4
2597 int
2598 main ()
2599 {
2600 static int test_array [1 - 2 * !(($2) < 0)];
2601 test_array [0] = 0;
2602 return test_array [0];
2603 
2604   ;
2605   return 0;
2606 }
2607 _ACEOF
2608 if ac_fn_cxx_try_compile "$LINENO"; then :
2609   ac_hi=-1 ac_mid=-1
2610   while :; do
2611     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2612 /* end confdefs.h.  */
2613 $4
2614 int
2615 main ()
2616 {
2617 static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2618 test_array [0] = 0;
2619 return test_array [0];
2620 
2621   ;
2622   return 0;
2623 }
2624 _ACEOF
2625 if ac_fn_cxx_try_compile "$LINENO"; then :
2626   ac_lo=$ac_mid; break
2627 else
2628   as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2629                         if test $ac_mid -le $ac_hi; then
2630                           ac_lo= ac_hi=
2631                           break
2632                         fi
2633                         as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2634 fi
2635 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2636   done
2637 else
2638   ac_lo= ac_hi=
2639 fi
2640 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2641 fi
2642 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2643 # Binary search between lo and hi bounds.
2644 while test "x$ac_lo" != "x$ac_hi"; do
2645   as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2646   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2647 /* end confdefs.h.  */
2648 $4
2649 int
2650 main ()
2651 {
2652 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2653 test_array [0] = 0;
2654 return test_array [0];
2655 
2656   ;
2657   return 0;
2658 }
2659 _ACEOF
2660 if ac_fn_cxx_try_compile "$LINENO"; then :
2661   ac_hi=$ac_mid
2662 else
2663   as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2664 fi
2665 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2666 done
2667 case $ac_lo in #((
2668 ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2669 '') ac_retval=1 ;;
2670 esac
2671   else
2672     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2673 /* end confdefs.h.  */
2674 $4
2675 static long int longval () { return $2; }
2676 static unsigned long int ulongval () { return $2; }
2677 #include <stdio.h>
2678 #include <stdlib.h>
2679 int
2680 main ()
2681 {
2682 
2683   FILE *f = fopen ("conftest.val", "w");
2684   if (! f)
2685     return 1;
2686   if (($2) < 0)
2687     {
2688       long int i = longval ();
2689       if (i != ($2))
2690         return 1;
2691       fprintf (f, "%ld", i);
2692     }
2693   else
2694     {
2695       unsigned long int i = ulongval ();
2696       if (i != ($2))
2697         return 1;
2698       fprintf (f, "%lu", i);
2699     }
2700   /* Do not output a trailing newline, as this causes \r\n confusion
2701      on some platforms.  */
2702   return ferror (f) || fclose (f) != 0;
2703 
2704   ;
2705   return 0;
2706 }
2707 _ACEOF
2708 if ac_fn_cxx_try_run "$LINENO"; then :
2709   echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2710 else
2711   ac_retval=1
2712 fi
2713 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2714   conftest.$ac_objext conftest.beam conftest.$ac_ext
2715 rm -f conftest.val
2716 
2717   fi
2718   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2719   as_fn_set_status $ac_retval
2720 
2721 } # ac_fn_cxx_compute_int
2722 
2723 # ac_fn_cxx_try_link LINENO
2724 # -------------------------
2725 # Try to link conftest.$ac_ext, and return whether this succeeded.
2726 ac_fn_cxx_try_link ()
2727 {
2728   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2729   rm -f conftest.$ac_objext conftest$ac_exeext
2730   if { { ac_try="$ac_link"
2731 case "(($ac_try" in
2732   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2733   *) ac_try_echo=$ac_try;;
2734 esac
2735 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2736 $as_echo "$ac_try_echo"; } >&5
2737   (eval "$ac_link") 2>conftest.err
2738   ac_status=$?
2739   if test -s conftest.err; then
2740     grep -v '^ *+' conftest.err >conftest.er1
2741     cat conftest.er1 >&5
2742     mv -f conftest.er1 conftest.err
2743   fi
2744   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2745   test $ac_status = 0; } && {
2746          test -z "$ac_cxx_werror_flag" ||
2747          test ! -s conftest.err
2748        } && test -s conftest$ac_exeext && {
2749          test "$cross_compiling" = yes ||
2750          test -x conftest$ac_exeext
2751        }; then :
2752   ac_retval=0
2753 else
2754   $as_echo "$as_me: failed program was:" >&5
2755 sed 's/^/| /' conftest.$ac_ext >&5
2756 
2757         ac_retval=1
2758 fi
2759   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2760   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2761   # interfere with the next link command; also delete a directory that is
2762   # left behind by Apple's compiler.  We do this before executing the actions.
2763   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2764   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2765   as_fn_set_status $ac_retval
2766 
2767 } # ac_fn_cxx_try_link
2768 
2769 # ac_fn_cxx_check_func LINENO FUNC VAR
2770 # ------------------------------------
2771 # Tests whether FUNC exists, setting the cache variable VAR accordingly
2772 ac_fn_cxx_check_func ()
2773 {
2774   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2775   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2776 $as_echo_n "checking for $2... " >&6; }
2777 if eval \${$3+:} false; then :
2778   $as_echo_n "(cached) " >&6
2779 else
2780   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2781 /* end confdefs.h.  */
2782 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
2783    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
2784 #define $2 innocuous_$2
2785 
2786 /* System header to define __stub macros and hopefully few prototypes,
2787     which can conflict with char $2 (); below.
2788     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2789     <limits.h> exists even on freestanding compilers.  */
2790 
2791 #ifdef __STDC__
2792 # include <limits.h>
2793 #else
2794 # include <assert.h>
2795 #endif
2796 
2797 #undef $2
2798 
2799 /* Override any GCC internal prototype to avoid an error.
2800    Use char because int might match the return type of a GCC
2801    builtin and then its argument prototype would still apply.  */
2802 #ifdef __cplusplus
2803 extern "C"
2804 #endif
2805 char $2 ();
2806 /* The GNU C library defines this for functions which it implements
2807     to always fail with ENOSYS.  Some functions are actually named
2808     something starting with __ and the normal name is an alias.  */
2809 #if defined __stub_$2 || defined __stub___$2
2810 choke me
2811 #endif
2812 
2813 int
2814 main ()
2815 {
2816 return $2 ();
2817   ;
2818   return 0;
2819 }
2820 _ACEOF
2821 if ac_fn_cxx_try_link "$LINENO"; then :
2822   eval "$3=yes"
2823 else
2824   eval "$3=no"
2825 fi
2826 rm -f core conftest.err conftest.$ac_objext \
2827     conftest$ac_exeext conftest.$ac_ext
2828 fi
2829 eval ac_res=\$$3
2830                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2831 $as_echo "$ac_res" >&6; }
2832   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2833 
2834 } # ac_fn_cxx_check_func
2835 
2836 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
2837 # -------------------------------------------------------
2838 # Tests whether HEADER exists and can be compiled using the include files in
2839 # INCLUDES, setting the cache variable VAR accordingly.
2840 ac_fn_c_check_header_compile ()
2841 {
2842   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2843   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2844 $as_echo_n "checking for $2... " >&6; }
2845 if eval \${$3+:} false; then :
2846   $as_echo_n "(cached) " >&6
2847 else
2848   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2849 /* end confdefs.h.  */
2850 $4
2851 #include <$2>
2852 _ACEOF
2853 if ac_fn_c_try_compile "$LINENO"; then :
2854   eval "$3=yes"
2855 else
2856   eval "$3=no"
2857 fi
2858 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2859 fi
2860 eval ac_res=\$$3
2861                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2862 $as_echo "$ac_res" >&6; }
2863   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2864 
2865 } # ac_fn_c_check_header_compile
2866 cat >config.log <<_ACEOF
2867 This file contains any messages produced by compilers while
2868 running configure, to aid debugging if configure makes a mistake.
2869 
2870 It was created by OpenJDK $as_me jdk8, which was
2871 generated by GNU Autoconf 2.69.  Invocation command line was
2872 
2873   $ $0 $@
2874 
2875 _ACEOF
2876 exec 5>>config.log
2877 {
2878 cat <<_ASUNAME
2879 ## --------- ##
2880 ## Platform. ##
2881 ## --------- ##
2882 
2883 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
2884 uname -m = `(uname -m) 2>/dev/null || echo unknown`
2885 uname -r = `(uname -r) 2>/dev/null || echo unknown`
2886 uname -s = `(uname -s) 2>/dev/null || echo unknown`
2887 uname -v = `(uname -v) 2>/dev/null || echo unknown`
2888 
2889 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
2890 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
2891 
2892 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
2893 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
2894 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
2895 /usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
2896 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
2897 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
2898 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
2899 
2900 _ASUNAME
2901 
2902 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2903 for as_dir in $PATH
2904 do
2905   IFS=$as_save_IFS
2906   test -z "$as_dir" && as_dir=.
2907     $as_echo "PATH: $as_dir"
2908   done
2909 IFS=$as_save_IFS
2910 
2911 } >&5
2912 
2913 cat >&5 <<_ACEOF
2914 
2915 
2916 ## ----------- ##
2917 ## Core tests. ##
2918 ## ----------- ##
2919 
2920 _ACEOF
2921 
2922 
2923 # Keep a trace of the command line.
2924 # Strip out --no-create and --no-recursion so they do not pile up.
2925 # Strip out --silent because we don't want to record it for future runs.
2926 # Also quote any args containing shell meta-characters.
2927 # Make two passes to allow for proper duplicate-argument suppression.
2928 ac_configure_args=
2929 ac_configure_args0=
2930 ac_configure_args1=
2931 ac_must_keep_next=false
2932 for ac_pass in 1 2
2933 do
2934   for ac_arg
2935   do
2936     case $ac_arg in
2937     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
2938     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
2939     | -silent | --silent | --silen | --sile | --sil)
2940       continue ;;
2941     *\'*)
2942       ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
2943     esac
2944     case $ac_pass in
2945     1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2946     2)
2947       as_fn_append ac_configure_args1 " '$ac_arg'"
2948       if test $ac_must_keep_next = true; then
2949         ac_must_keep_next=false # Got value, back to normal.
2950       else
2951         case $ac_arg in
2952           *=* | --config-cache | -C | -disable-* | --disable-* \
2953           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
2954           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
2955           | -with-* | --with-* | -without-* | --without-* | --x)
2956             case "$ac_configure_args0 " in
2957               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
2958             esac
2959             ;;
2960           -* ) ac_must_keep_next=true ;;
2961         esac
2962       fi
2963       as_fn_append ac_configure_args " '$ac_arg'"
2964       ;;
2965     esac
2966   done
2967 done
2968 { ac_configure_args0=; unset ac_configure_args0;}
2969 { ac_configure_args1=; unset ac_configure_args1;}
2970 
2971 # When interrupted or exit'd, cleanup temporary files, and complete
2972 # config.log.  We remove comments because anyway the quotes in there
2973 # would cause problems or look ugly.
2974 # WARNING: Use '\'' to represent an apostrophe within the trap.
2975 # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
2976 trap 'exit_status=$?
2977   # Save into config.log some information that might help in debugging.
2978   {
2979     echo
2980 
2981     $as_echo "## ---------------- ##
2982 ## Cache variables. ##
2983 ## ---------------- ##"
2984     echo
2985     # The following way of writing the cache mishandles newlines in values,
2986 (
2987   for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
2988     eval ac_val=\$$ac_var
2989     case $ac_val in #(
2990     *${as_nl}*)
2991       case $ac_var in #(
2992       *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
2993 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
2994       esac
2995       case $ac_var in #(
2996       _ | IFS | as_nl) ;; #(
2997       BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
2998       *) { eval $ac_var=; unset $ac_var;} ;;
2999       esac ;;
3000     esac
3001   done
3002   (set) 2>&1 |
3003     case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
3004     *${as_nl}ac_space=\ *)
3005       sed -n \
3006         "s/'\''/'\''\\\\'\'''\''/g;
3007           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
3008       ;; #(
3009     *)
3010       sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
3011       ;;
3012     esac |
3013     sort
3014 )
3015     echo
3016 
3017     $as_echo "## ----------------- ##
3018 ## Output variables. ##
3019 ## ----------------- ##"
3020     echo
3021     for ac_var in $ac_subst_vars
3022     do
3023       eval ac_val=\$$ac_var
3024       case $ac_val in
3025       *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3026       esac
3027       $as_echo "$ac_var='\''$ac_val'\''"
3028     done | sort
3029     echo
3030 
3031     if test -n "$ac_subst_files"; then
3032       $as_echo "## ------------------- ##
3033 ## File substitutions. ##
3034 ## ------------------- ##"
3035       echo
3036       for ac_var in $ac_subst_files
3037       do
3038         eval ac_val=\$$ac_var
3039         case $ac_val in
3040         *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3041         esac
3042         $as_echo "$ac_var='\''$ac_val'\''"
3043       done | sort
3044       echo
3045     fi
3046 
3047     if test -s confdefs.h; then
3048       $as_echo "## ----------- ##
3049 ## confdefs.h. ##
3050 ## ----------- ##"
3051       echo
3052       cat confdefs.h
3053       echo
3054     fi
3055     test "$ac_signal" != 0 &&
3056       $as_echo "$as_me: caught signal $ac_signal"
3057     $as_echo "$as_me: exit $exit_status"
3058   } >&5
3059   rm -f core *.core core.conftest.* &&
3060     rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
3061     exit $exit_status
3062 ' 0
3063 for ac_signal in 1 2 13 15; do
3064   trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
3065 done
3066 ac_signal=0
3067 
3068 # confdefs.h avoids OS command line length limits that DEFS can exceed.
3069 rm -f -r conftest* confdefs.h
3070 
3071 $as_echo "/* confdefs.h */" > confdefs.h
3072 
3073 # Predefined preprocessor variables.
3074 
3075 cat >>confdefs.h <<_ACEOF
3076 #define PACKAGE_NAME "$PACKAGE_NAME"
3077 _ACEOF
3078 
3079 cat >>confdefs.h <<_ACEOF
3080 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
3081 _ACEOF
3082 
3083 cat >>confdefs.h <<_ACEOF
3084 #define PACKAGE_VERSION "$PACKAGE_VERSION"
3085 _ACEOF
3086 
3087 cat >>confdefs.h <<_ACEOF
3088 #define PACKAGE_STRING "$PACKAGE_STRING"
3089 _ACEOF
3090 
3091 cat >>confdefs.h <<_ACEOF
3092 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
3093 _ACEOF
3094 
3095 cat >>confdefs.h <<_ACEOF
3096 #define PACKAGE_URL "$PACKAGE_URL"
3097 _ACEOF
3098 
3099 
3100 # Let the site file select an alternate cache file if it wants to.
3101 # Prefer an explicitly selected file to automatically selected ones.
3102 ac_site_file1=NONE
3103 ac_site_file2=NONE
3104 if test -n "$CONFIG_SITE"; then
3105   # We do not want a PATH search for config.site.
3106   case $CONFIG_SITE in #((
3107     -*)  ac_site_file1=./$CONFIG_SITE;;
3108     */*) ac_site_file1=$CONFIG_SITE;;
3109     *)   ac_site_file1=./$CONFIG_SITE;;
3110   esac
3111 elif test "x$prefix" != xNONE; then
3112   ac_site_file1=$prefix/share/config.site
3113   ac_site_file2=$prefix/etc/config.site
3114 else
3115   ac_site_file1=$ac_default_prefix/share/config.site
3116   ac_site_file2=$ac_default_prefix/etc/config.site
3117 fi
3118 for ac_site_file in "$ac_site_file1" "$ac_site_file2"
3119 do
3120   test "x$ac_site_file" = xNONE && continue
3121   if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
3122     { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
3123 $as_echo "$as_me: loading site script $ac_site_file" >&6;}
3124     sed 's/^/| /' "$ac_site_file" >&5
3125     . "$ac_site_file" \
3126       || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3127 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3128 as_fn_error $? "failed to load site script $ac_site_file
3129 See \`config.log' for more details" "$LINENO" 5; }
3130   fi
3131 done
3132 
3133 if test -r "$cache_file"; then
3134   # Some versions of bash will fail to source /dev/null (special files
3135   # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
3136   if test /dev/null != "$cache_file" && test -f "$cache_file"; then
3137     { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
3138 $as_echo "$as_me: loading cache $cache_file" >&6;}
3139     case $cache_file in
3140       [\\/]* | ?:[\\/]* ) . "$cache_file";;
3141       *)                      . "./$cache_file";;
3142     esac
3143   fi
3144 else
3145   { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
3146 $as_echo "$as_me: creating cache $cache_file" >&6;}
3147   >$cache_file
3148 fi
3149 
3150 # Check that the precious variables saved in the cache have kept the same
3151 # value.
3152 ac_cache_corrupted=false
3153 for ac_var in $ac_precious_vars; do
3154   eval ac_old_set=\$ac_cv_env_${ac_var}_set
3155   eval ac_new_set=\$ac_env_${ac_var}_set
3156   eval ac_old_val=\$ac_cv_env_${ac_var}_value
3157   eval ac_new_val=\$ac_env_${ac_var}_value
3158   case $ac_old_set,$ac_new_set in
3159     set,)
3160       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
3161 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
3162       ac_cache_corrupted=: ;;
3163     ,set)
3164       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
3165 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
3166       ac_cache_corrupted=: ;;
3167     ,);;
3168     *)
3169       if test "x$ac_old_val" != "x$ac_new_val"; then
3170         # differences in whitespace do not lead to failure.
3171         ac_old_val_w=`echo x $ac_old_val`
3172         ac_new_val_w=`echo x $ac_new_val`
3173         if test "$ac_old_val_w" != "$ac_new_val_w"; then
3174           { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
3175 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
3176           ac_cache_corrupted=:
3177         else
3178           { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
3179 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
3180           eval $ac_var=\$ac_old_val
3181         fi
3182         { $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
3183 $as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
3184         { $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
3185 $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
3186       fi;;
3187   esac
3188   # Pass precious variables to config.status.
3189   if test "$ac_new_set" = set; then
3190     case $ac_new_val in
3191     *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
3192     *) ac_arg=$ac_var=$ac_new_val ;;
3193     esac
3194     case " $ac_configure_args " in
3195       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
3196       *) as_fn_append ac_configure_args " '$ac_arg'" ;;
3197     esac
3198   fi
3199 done
3200 if $ac_cache_corrupted; then
3201   { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3202 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3203   { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
3204 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
3205   as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
3206 fi
3207 ## -------------------- ##
3208 ## Main body of script. ##
3209 ## -------------------- ##
3210 
3211 ac_ext=c
3212 ac_cpp='$CPP $CPPFLAGS'
3213 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3214 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3215 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3216 
3217 
3218 
3219 ac_aux_dir=
3220 for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
3221   if test -f "$ac_dir/install-sh"; then
3222     ac_aux_dir=$ac_dir
3223     ac_install_sh="$ac_aux_dir/install-sh -c"
3224     break
3225   elif test -f "$ac_dir/install.sh"; then
3226     ac_aux_dir=$ac_dir
3227     ac_install_sh="$ac_aux_dir/install.sh -c"
3228     break
3229   elif test -f "$ac_dir/shtool"; then
3230     ac_aux_dir=$ac_dir
3231     ac_install_sh="$ac_aux_dir/shtool install -c"
3232     break
3233   fi
3234 done
3235 if test -z "$ac_aux_dir"; then
3236   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
3237 fi
3238 
3239 # These three variables are undocumented and unsupported,
3240 # and are intended to be withdrawn in a future Autoconf release.
3241 # They can cause serious problems if a builder's source tree is in a directory
3242 # whose full name contains unusual characters.
3243 ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
3244 ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
3245 ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
3246 
3247 
3248 # pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
3249 
3250 #
3251 # Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3252 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3253 #
3254 # This code is free software; you can redistribute it and/or modify it
3255 # under the terms of the GNU General Public License version 2 only, as
3256 # published by the Free Software Foundation.  Oracle designates this
3257 # particular file as subject to the "Classpath" exception as provided
3258 # by Oracle in the LICENSE file that accompanied this code.
3259 #
3260 # This code is distributed in the hope that it will be useful, but WITHOUT
3261 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3262 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3263 # version 2 for more details (a copy is included in the LICENSE file that
3264 # accompanied this code).
3265 #
3266 # You should have received a copy of the GNU General Public License version
3267 # 2 along with this work; if not, write to the Free Software Foundation,
3268 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3269 #
3270 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3271 # or visit www.oracle.com if you need additional information or have any
3272 # questions.
3273 #
3274 
3275 #
3276 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
3277 #
3278 # This program is free software; you can redistribute it and/or modify
3279 # it under the terms of the GNU General Public License as published by
3280 # the Free Software Foundation; either version 2 of the License, or
3281 # (at your option) any later version.
3282 #
3283 # This program is distributed in the hope that it will be useful, but
3284 # WITHOUT ANY WARRANTY; without even the implied warranty of
3285 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3286 # General Public License for more details.
3287 #
3288 # You should have received a copy of the GNU General Public License
3289 # along with this program; if not, write to the Free Software
3290 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3291 #
3292 # As a special exception to the GNU General Public License, if you
3293 # distribute this file as part of a program that contains a
3294 # configuration script generated by Autoconf, you may include it under
3295 # the same distribution terms that you use for the rest of that program.
3296 
3297 # PKG_PROG_PKG_CONFIG([MIN-VERSION])
3298 # ----------------------------------
3299 # PKG_PROG_PKG_CONFIG
3300 
3301 # PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
3302 #
3303 # Check to see whether a particular set of modules exists.  Similar
3304 # to PKG_CHECK_MODULES(), but does not set variables or print errors.
3305 #
3306 #
3307 # Similar to PKG_CHECK_MODULES, make sure that the first instance of
3308 # this or PKG_CHECK_MODULES is called, or make sure to call
3309 # PKG_CHECK_EXISTS manually
3310 # --------------------------------------------------------------
3311 
3312 
3313 
3314 # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
3315 # ---------------------------------------------
3316 # _PKG_CONFIG
3317 
3318 # _PKG_SHORT_ERRORS_SUPPORTED
3319 # -----------------------------
3320 # _PKG_SHORT_ERRORS_SUPPORTED
3321 
3322 
3323 # PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
3324 # [ACTION-IF-NOT-FOUND])
3325 #
3326 #
3327 # Note that if there is a possibility the first call to
3328 # PKG_CHECK_MODULES might not happen, you should be sure to include an
3329 # explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
3330 #
3331 #
3332 # --------------------------------------------------------------
3333 # PKG_CHECK_MODULES
3334 
3335 
3336 # Include these first...
3337 #
3338 # Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved.
3339 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3340 #
3341 # This code is free software; you can redistribute it and/or modify it
3342 # under the terms of the GNU General Public License version 2 only, as
3343 # published by the Free Software Foundation.  Oracle designates this
3344 # particular file as subject to the "Classpath" exception as provided
3345 # by Oracle in the LICENSE file that accompanied this code.
3346 #
3347 # This code is distributed in the hope that it will be useful, but WITHOUT
3348 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3349 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3350 # version 2 for more details (a copy is included in the LICENSE file that
3351 # accompanied this code).
3352 #
3353 # You should have received a copy of the GNU General Public License version
3354 # 2 along with this work; if not, write to the Free Software Foundation,
3355 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3356 #
3357 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3358 # or visit www.oracle.com if you need additional information or have any
3359 # questions.
3360 #
3361 
3362 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3363 # If so, then append $1 to $2 \
3364 # Also set JVM_ARG_OK to true/false depending on outcome.
3365 
3366 
3367 # Appends a string to a path variable, only adding the : when needed.
3368 
3369 
3370 # Prepends a string to a path variable, only adding the : when needed.
3371 
3372 
3373 # This will make sure the given variable points to a full and proper
3374 # path. This means:
3375 # 1) There will be no spaces in the path. On posix platforms,
3376 #    spaces in the path will result in an error. On Windows,
3377 #    the path will be rewritten using short-style to be space-free.
3378 # 2) The path will be absolute, and it will be in unix-style (on
3379 #     cygwin).
3380 # $1: The name of the variable to fix
3381 
3382 
3383 # This will make sure the given variable points to a executable
3384 # with a full and proper path. This means:
3385 # 1) There will be no spaces in the path. On posix platforms,
3386 #    spaces in the path will result in an error. On Windows,
3387 #    the path will be rewritten using short-style to be space-free.
3388 # 2) The path will be absolute, and it will be in unix-style (on
3389 #     cygwin).
3390 # Any arguments given to the executable is preserved.
3391 # If the input variable does not have a directory specification, then
3392 # it need to be in the PATH.
3393 # $1: The name of the variable to fix
3394 
3395 
3396 
3397 
3398 # Register a --with argument but mark it as deprecated
3399 # $1: The name of the with argument to deprecate, not including --with-
3400 
3401 
3402 # Register a --enable argument but mark it as deprecated
3403 # $1: The name of the with argument to deprecate, not including --enable-
3404 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3405 
3406 
3407 
3408 
3409 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3410 # $1: variable to check
3411 
3412 
3413 # Check that there are no unprocessed overridden variables left.
3414 # If so, they are an incorrect argument and we will exit with an error.
3415 
3416 
3417 # Setup a tool for the given variable. If correctly specified by the user,
3418 # use that value, otherwise search for the tool using the supplied code snippet.
3419 # $1: variable to set
3420 # $2: code snippet to call to look for the tool
3421 
3422 
3423 # Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
3424 # $1: variable to set
3425 # $2: executable name (or list of names) to look for
3426 
3427 
3428 # Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
3429 # $1: variable to set
3430 # $2: executable name (or list of names) to look for
3431 
3432 
3433 # Like BASIC_PATH_PROGS but fails if no tool was found.
3434 # $1: variable to set
3435 # $2: executable name (or list of names) to look for
3436 
3437 
3438 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3439 # $1: variable to set
3440 # $2: autoconf macro to call to look for the special tool
3441 
3442 
3443 # Setup the most fundamental tools that relies on not much else to set up,
3444 # but is used by much of the early bootstrap code.
3445 
3446 
3447 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3448 
3449 
3450 # Evaluates platform specific overrides for devkit variables.
3451 # $1: Name of variable
3452 
3453 
3454 
3455 
3456 
3457 
3458 
3459 
3460 
3461 #%%% Simple tools %%%
3462 
3463 # Check if we have found a usable version of make
3464 # $1: the path to a potential make binary (or empty)
3465 # $2: the description on how we found this
3466 
3467 
3468 # Goes looking for a usable version of GNU make.
3469 
3470 
3471 
3472 
3473 
3474 
3475 # Check if build directory is on local disk. If not possible to determine,
3476 # we prefer to claim it's local.
3477 # Argument 1: directory to test
3478 # Argument 2: what to do if it is on local disk
3479 # Argument 3: what to do otherwise (remote disk or failure)
3480 
3481 
3482 # Check that source files have basic read permissions set. This might
3483 # not be the case in cygwin in certain conditions.
3484 
3485 
3486 
3487 
3488 #
3489 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3490 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3491 #
3492 # This code is free software; you can redistribute it and/or modify it
3493 # under the terms of the GNU General Public License version 2 only, as
3494 # published by the Free Software Foundation.  Oracle designates this
3495 # particular file as subject to the "Classpath" exception as provided
3496 # by Oracle in the LICENSE file that accompanied this code.
3497 #
3498 # This code is distributed in the hope that it will be useful, but WITHOUT
3499 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3500 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3501 # version 2 for more details (a copy is included in the LICENSE file that
3502 # accompanied this code).
3503 #
3504 # You should have received a copy of the GNU General Public License version
3505 # 2 along with this work; if not, write to the Free Software Foundation,
3506 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3507 #
3508 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3509 # or visit www.oracle.com if you need additional information or have any
3510 # questions.
3511 #
3512 
3513 
3514 
3515 
3516 
3517 # Helper function which possibly converts a path using DOS-style short mode.
3518 # If so, the updated path is stored in $new_path.
3519 # $1: The path to check
3520 
3521 
3522 # Helper function which possibly converts a path using DOS-style short mode.
3523 # If so, the updated path is stored in $new_path.
3524 # $1: The path to check
3525 
3526 
3527 # FIXME: The BASIC_FIXUP_*_CYGWIN/MSYS is most likely too convoluted
3528 # and could probably be heavily simplified. However, all changes in this
3529 # area tend to need lot of testing in different scenarios, and in lack of
3530 # proper unit testing, cleaning this up has not been deemed worth the effort
3531 # at the moment.
3532 
3533 
3534 
3535 
3536 
3537 
3538 
3539 
3540 
3541 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3542 
3543 
3544 
3545 
3546 #
3547 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3548 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3549 #
3550 # This code is free software; you can redistribute it and/or modify it
3551 # under the terms of the GNU General Public License version 2 only, as
3552 # published by the Free Software Foundation.  Oracle designates this
3553 # particular file as subject to the "Classpath" exception as provided
3554 # by Oracle in the LICENSE file that accompanied this code.
3555 #
3556 # This code is distributed in the hope that it will be useful, but WITHOUT
3557 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3558 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3559 # version 2 for more details (a copy is included in the LICENSE file that
3560 # accompanied this code).
3561 #
3562 # You should have received a copy of the GNU General Public License version
3563 # 2 along with this work; if not, write to the Free Software Foundation,
3564 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3565 #
3566 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3567 # or visit www.oracle.com if you need additional information or have any
3568 # questions.
3569 #
3570 
3571 
3572 
3573 
3574 
3575 
3576 
3577 
3578 
3579 
3580 
3581 # ... then the rest
3582 #
3583 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3584 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3585 #
3586 # This code is free software; you can redistribute it and/or modify it
3587 # under the terms of the GNU General Public License version 2 only, as
3588 # published by the Free Software Foundation.  Oracle designates this
3589 # particular file as subject to the "Classpath" exception as provided
3590 # by Oracle in the LICENSE file that accompanied this code.
3591 #
3592 # This code is distributed in the hope that it will be useful, but WITHOUT
3593 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3594 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3595 # version 2 for more details (a copy is included in the LICENSE file that
3596 # accompanied this code).
3597 #
3598 # You should have received a copy of the GNU General Public License version
3599 # 2 along with this work; if not, write to the Free Software Foundation,
3600 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3601 #
3602 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3603 # or visit www.oracle.com if you need additional information or have any
3604 # questions.
3605 #
3606 
3607 # Execute the check given as argument, and verify the result
3608 # If the Boot JDK was previously found, do nothing
3609 # $1 A command line (typically autoconf macro) to execute
3610 
3611 
3612 # Test: Is bootjdk explicitely set by command line arguments?
3613 
3614 
3615 # Test: Is bootjdk available from builddeps?
3616 
3617 
3618 # Test: Is $JAVA_HOME set?
3619 
3620 
3621 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
3622 
3623 
3624 # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
3625 
3626 
3627 # Look for a jdk in the given path. If there are multiple, try to select the newest.
3628 # If found, set BOOT_JDK and BOOT_JDK_FOUND.
3629 # $1 = Path to directory containing jdk installations.
3630 # $2 = String to append to the found JDK directory to get the proper JDK home
3631 
3632 
3633 # Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
3634 # environmental variable as base for where to look.
3635 # $1 Name of an environmal variable, assumed to point to the Program Files directory.
3636 
3637 
3638 # Test: Is there a JDK installed in default, well-known locations?
3639 
3640 
3641 # Check that a command-line tool in the Boot JDK is correct
3642 # $1 = name of variable to assign
3643 # $2 = name of binary
3644 
3645 
3646 ###############################################################################
3647 #
3648 # We need a Boot JDK to bootstrap the build.
3649 #
3650 
3651 
3652 
3653 
3654 
3655 #
3656 # Copyright (c) 2011, 2019, Oracle and/or its affiliates. All rights reserved.
3657 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3658 #
3659 # This code is free software; you can redistribute it and/or modify it
3660 # under the terms of the GNU General Public License version 2 only, as
3661 # published by the Free Software Foundation.  Oracle designates this
3662 # particular file as subject to the "Classpath" exception as provided
3663 # by Oracle in the LICENSE file that accompanied this code.
3664 #
3665 # This code is distributed in the hope that it will be useful, but WITHOUT
3666 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3667 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3668 # version 2 for more details (a copy is included in the LICENSE file that
3669 # accompanied this code).
3670 #
3671 # You should have received a copy of the GNU General Public License version
3672 # 2 along with this work; if not, write to the Free Software Foundation,
3673 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3674 #
3675 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3676 # or visit www.oracle.com if you need additional information or have any
3677 # questions.
3678 #
3679 
3680 
3681 
3682 
3683 
3684 
3685 
3686 
3687 
3688 
3689 
3690 
3691 
3692 
3693 
3694 
3695 
3696 
3697 
3698 
3699 #
3700 # Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved.
3701 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3702 #
3703 # This code is free software; you can redistribute it and/or modify it
3704 # under the terms of the GNU General Public License version 2 only, as
3705 # published by the Free Software Foundation.  Oracle designates this
3706 # particular file as subject to the "Classpath" exception as provided
3707 # by Oracle in the LICENSE file that accompanied this code.
3708 #
3709 # This code is distributed in the hope that it will be useful, but WITHOUT
3710 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3711 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3712 # version 2 for more details (a copy is included in the LICENSE file that
3713 # accompanied this code).
3714 #
3715 # You should have received a copy of the GNU General Public License version
3716 # 2 along with this work; if not, write to the Free Software Foundation,
3717 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3718 #
3719 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3720 # or visit www.oracle.com if you need additional information or have any
3721 # questions.
3722 #
3723 
3724 
3725 
3726 
3727 
3728 # Documentation on common flags used for solstudio in HIGHEST.
3729 #
3730 # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
3731 #          done with care, there are some assumptions below that need to
3732 #          be understood about the use of pointers, and IEEE behavior.
3733 #
3734 # -fns: Use non-standard floating point mode (not IEEE 754)
3735 # -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)
3736 # -fsingle: Use single precision floating point with 'float'
3737 # -xalias_level=basic: Assume memory references via basic pointer types do not alias
3738 #   (Source with excessing pointer casting and data access with mixed
3739 #    pointer types are not recommended)
3740 # -xbuiltin=%all: Use intrinsic or inline versions for math/std functions
3741 #   (If you expect perfect errno behavior, do not use this)
3742 # -xdepend: Loop data dependency optimizations (need -xO3 or higher)
3743 # -xrestrict: Pointer parameters to functions do not overlap
3744 #   (Similar to -xalias_level=basic usage, but less obvious sometimes.
3745 #    If you pass in multiple pointers to the same data, do not use this)
3746 # -xlibmil: Inline some library routines
3747 #   (If you expect perfect errno behavior, do not use this)
3748 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
3749 #   (If you expect perfect errno behavior, do not use this)
3750 #  Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
3751 
3752     # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
3753     # Bug?
3754     #if test "x$OPENJDK_TARGET_CPU" = xsparc; then
3755     #  CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
3756     #  CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
3757     #fi
3758 
3759 
3760 
3761 
3762 
3763 
3764 # FLAGS_C_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3765 #                                  [RUN-IF-FALSE])
3766 # ------------------------------------------------------------
3767 # Check that the C compiler supports an argument
3768 
3769 
3770 # FLAGS_CXX_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3771 #                                    [RUN-IF-FALSE])
3772 # ------------------------------------------------------------
3773 # Check that the C++ compiler supports an argument
3774 
3775 
3776 # FLAGS_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3777 #                                [RUN-IF-FALSE])
3778 # ------------------------------------------------------------
3779 # Check that the C and C++ compilers support an argument
3780 
3781 
3782 
3783 
3784 
3785 
3786 
3787 #
3788 # Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved.
3789 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3790 #
3791 # This code is free software; you can redistribute it and/or modify it
3792 # under the terms of the GNU General Public License version 2 only, as
3793 # published by the Free Software Foundation.  Oracle designates this
3794 # particular file as subject to the "Classpath" exception as provided
3795 # by Oracle in the LICENSE file that accompanied this code.
3796 #
3797 # This code is distributed in the hope that it will be useful, but WITHOUT
3798 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3799 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3800 # version 2 for more details (a copy is included in the LICENSE file that
3801 # accompanied this code).
3802 #
3803 # You should have received a copy of the GNU General Public License version
3804 # 2 along with this work; if not, write to the Free Software Foundation,
3805 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3806 #
3807 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3808 # or visit www.oracle.com if you need additional information or have any
3809 # questions.
3810 #
3811 
3812 
3813 
3814 
3815 
3816 cygwin_help() {
3817   case $1 in
3818     unzip)
3819       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P unzip )"
3820       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3821       ;;
3822     zip)
3823       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P zip )"
3824       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3825       ;;
3826     make)
3827       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P make )"
3828       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3829       ;;
3830     freetype)
3831       HELP_MSG="
3832 The freetype library can now be build during the configure process.
3833 Download the freetype sources and unpack them into an arbitrary directory:
3834 
3835 wget http://download.savannah.gnu.org/releases/freetype/freetype-2.5.3.tar.gz
3836 tar -xzf freetype-2.5.3.tar.gz
3837 
3838 Then run configure with '--with-freetype-src=<freetype_src>'. This will
3839 automatically build the freetype library into '<freetype_src>/lib64' for 64-bit
3840 builds or into '<freetype_src>/lib32' for 32-bit builds.
3841 Afterwards you can always use '--with-freetype-include=<freetype_src>/include'
3842 and '--with-freetype-lib=<freetype_src>/lib32|64' for other builds."
3843       ;;
3844   esac
3845 }
3846 
3847 msys_help() {
3848   PKGHANDLER_COMMAND=""
3849 }
3850 
3851 apt_help() {
3852   case $1 in
3853     devkit)
3854       PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;;
3855     openjdk)
3856       PKGHANDLER_COMMAND="sudo apt-get install openjdk-7-jdk" ;;
3857     alsa)
3858       PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;;
3859     cups)
3860       PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;;
3861     fontconfig)
3862       PKGHANDLER_COMMAND="sudo apt-get install libfontconfig1-dev" ;;
3863     freetype)
3864       PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;;
3865     pulse)
3866       PKGHANDLER_COMMAND="sudo apt-get install libpulse-dev" ;;
3867     x11)
3868       PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
3869     ccache)
3870       PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
3871   esac
3872 }
3873 
3874 yum_help() {
3875   case $1 in
3876     devkit)
3877       PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;;
3878     openjdk)
3879       PKGHANDLER_COMMAND="sudo yum install java-1.7.0-openjdk" ;;
3880     alsa)
3881       PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;;
3882     cups)
3883       PKGHANDLER_COMMAND="sudo yum install cups-devel" ;;
3884     fontconfig)
3885       PKGHANDLER_COMMAND="sudo yum install fontconfig-devel" ;;
3886     freetype)
3887       PKGHANDLER_COMMAND="sudo yum install freetype-devel" ;;
3888     pulse)
3889       PKGHANDLER_COMMAND="sudo yum install pulseaudio-libs-devel" ;;
3890     x11)
3891       PKGHANDLER_COMMAND="sudo yum install libXtst-devel libXt-devel libXrender-devel" ;;
3892     ccache)
3893       PKGHANDLER_COMMAND="sudo yum install ccache" ;;
3894   esac
3895 }
3896 
3897 port_help() {
3898   PKGHANDLER_COMMAND=""
3899 }
3900 
3901 pkgutil_help() {
3902   PKGHANDLER_COMMAND=""
3903 }
3904 
3905 pkgadd_help() {
3906   PKGHANDLER_COMMAND=""
3907 }
3908 
3909 # This function will check if we're called from the "configure" wrapper while
3910 # printing --help. If so, we will print out additional information that can
3911 # only be extracted within the autoconf script, and then exit. This must be
3912 # called at the very beginning in configure.ac.
3913 
3914 
3915 
3916 
3917 #
3918 # Copyright (c) 2011, 2020, Oracle and/or its affiliates. All rights reserved.
3919 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3920 #
3921 # This code is free software; you can redistribute it and/or modify it
3922 # under the terms of the GNU General Public License version 2 only, as
3923 # published by the Free Software Foundation.  Oracle designates this
3924 # particular file as subject to the "Classpath" exception as provided
3925 # by Oracle in the LICENSE file that accompanied this code.
3926 #
3927 # This code is distributed in the hope that it will be useful, but WITHOUT
3928 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3929 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3930 # version 2 for more details (a copy is included in the LICENSE file that
3931 # accompanied this code).
3932 #
3933 # You should have received a copy of the GNU General Public License version
3934 # 2 along with this work; if not, write to the Free Software Foundation,
3935 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3936 #
3937 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3938 # or visit www.oracle.com if you need additional information or have any
3939 # questions.
3940 #
3941 
3942 
3943 
3944 
3945 
3946 
3947 
3948 
3949 
3950 
3951 ###############################################################################
3952 #
3953 # Should we build only OpenJDK even if closed sources are present?
3954 #
3955 
3956 
3957 
3958 
3959 ###############################################################################
3960 #
3961 # Setup version numbers
3962 #
3963 
3964 
3965 
3966 
3967 
3968 
3969 # Support for customization of the build process. Some build files
3970 # will include counterparts from this location, if they exist. This allows
3971 # for a degree of customization of the build targets and the rules/recipes
3972 # to create them
3973 
3974 # Check whether --with-custom-make-dir was given.
3975 if test "${with_custom_make_dir+set}" = set; then :
3976   withval=$with_custom_make_dir; CUSTOM_MAKE_DIR=$with_custom_make_dir
3977 fi
3978 
3979 
3980 
3981 #
3982 # Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved.
3983 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3984 #
3985 # This code is free software; you can redistribute it and/or modify it
3986 # under the terms of the GNU General Public License version 2 only, as
3987 # published by the Free Software Foundation.  Oracle designates this
3988 # particular file as subject to the "Classpath" exception as provided
3989 # by Oracle in the LICENSE file that accompanied this code.
3990 #
3991 # This code is distributed in the hope that it will be useful, but WITHOUT
3992 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3993 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3994 # version 2 for more details (a copy is included in the LICENSE file that
3995 # accompanied this code).
3996 #
3997 # You should have received a copy of the GNU General Public License version
3998 # 2 along with this work; if not, write to the Free Software Foundation,
3999 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4000 #
4001 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4002 # or visit www.oracle.com if you need additional information or have any
4003 # questions.
4004 #
4005 
4006 
4007 
4008 
4009 
4010 
4011 
4012 
4013 
4014 
4015 
4016 
4017 
4018 
4019 
4020 ################################################################################
4021 # Setup fontconfig
4022 ################################################################################
4023 
4024 
4025 
4026 
4027 
4028 
4029 
4030 
4031 #
4032 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4033 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4034 #
4035 # This code is free software; you can redistribute it and/or modify it
4036 # under the terms of the GNU General Public License version 2 only, as
4037 # published by the Free Software Foundation.  Oracle designates this
4038 # particular file as subject to the "Classpath" exception as provided
4039 # by Oracle in the LICENSE file that accompanied this code.
4040 #
4041 # This code is distributed in the hope that it will be useful, but WITHOUT
4042 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4043 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4044 # version 2 for more details (a copy is included in the LICENSE file that
4045 # accompanied this code).
4046 #
4047 # You should have received a copy of the GNU General Public License version
4048 # 2 along with this work; if not, write to the Free Software Foundation,
4049 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4050 #
4051 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4052 # or visit www.oracle.com if you need additional information or have any
4053 # questions.
4054 #
4055 
4056 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4057 # Converts autoconf style CPU name to OpenJDK style, into
4058 # VAR_CPU, VAR_CPU_ARCH, VAR_CPU_BITS and VAR_CPU_ENDIAN.
4059 
4060 
4061 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4062 # Converts autoconf style OS name to OpenJDK style, into
4063 # VAR_OS and VAR_OS_API.
4064 
4065 
4066 # Expects $host_os $host_cpu $build_os and $build_cpu
4067 # and $with_target_bits to have been setup!
4068 #
4069 # Translate the standard triplet(quadruplet) definition
4070 # of the target/build system into OPENJDK_TARGET_OS, OPENJDK_TARGET_CPU,
4071 # OPENJDK_BUILD_OS, etc.
4072 
4073 
4074 # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
4075 # accordingly. Must be done after setting up build and target system, but before
4076 # doing anything else with these values.
4077 
4078 
4079 # Setup the legacy variables, for controlling the old makefiles.
4080 #
4081 
4082 
4083 
4084 
4085 #%%% Build and target systems %%%
4086 
4087 
4088 
4089 
4090 # Support macro for PLATFORM_SETUP_OPENJDK_TARGET_BITS.
4091 # Add -mX to various FLAGS variables.
4092 
4093 
4094 
4095 
4096 
4097 
4098 #
4099 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4100 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4101 #
4102 # This code is free software; you can redistribute it and/or modify it
4103 # under the terms of the GNU General Public License version 2 only, as
4104 # published by the Free Software Foundation.  Oracle designates this
4105 # particular file as subject to the "Classpath" exception as provided
4106 # by Oracle in the LICENSE file that accompanied this code.
4107 #
4108 # This code is distributed in the hope that it will be useful, but WITHOUT
4109 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4110 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4111 # version 2 for more details (a copy is included in the LICENSE file that
4112 # accompanied this code).
4113 #
4114 # You should have received a copy of the GNU General Public License version
4115 # 2 along with this work; if not, write to the Free Software Foundation,
4116 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4117 #
4118 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4119 # or visit www.oracle.com if you need additional information or have any
4120 # questions.
4121 #
4122 
4123 
4124 
4125 
4126 
4127 
4128 
4129 
4130 #
4131 # Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved.
4132 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4133 #
4134 # This code is free software; you can redistribute it and/or modify it
4135 # under the terms of the GNU General Public License version 2 only, as
4136 # published by the Free Software Foundation.  Oracle designates this
4137 # particular file as subject to the "Classpath" exception as provided
4138 # by Oracle in the LICENSE file that accompanied this code.
4139 #
4140 # This code is distributed in the hope that it will be useful, but WITHOUT
4141 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4142 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4143 # version 2 for more details (a copy is included in the LICENSE file that
4144 # accompanied this code).
4145 #
4146 # You should have received a copy of the GNU General Public License version
4147 # 2 along with this work; if not, write to the Free Software Foundation,
4148 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4149 #
4150 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4151 # or visit www.oracle.com if you need additional information or have any
4152 # questions.
4153 #
4154 
4155 ########################################################################
4156 # This file is responsible for detecting, verifying and setting up the
4157 # toolchain, i.e. the compiler, linker and related utilities. It will setup
4158 # proper paths to the binaries, but it will not setup any flags.
4159 #
4160 # The binaries used is determined by the toolchain type, which is the family of
4161 # compilers and related tools that are used.
4162 ########################################################################
4163 
4164 
4165 # All valid toolchains, regardless of platform (used by help.m4)
4166 VALID_TOOLCHAINS_all="gcc clang solstudio xlc microsoft"
4167 
4168 # These toolchains are valid on different platforms
4169 VALID_TOOLCHAINS_linux="gcc clang"
4170 VALID_TOOLCHAINS_solaris="solstudio"
4171 VALID_TOOLCHAINS_macosx="gcc clang"
4172 VALID_TOOLCHAINS_aix="xlc"
4173 VALID_TOOLCHAINS_windows="microsoft"
4174 
4175 # Toolchain descriptions
4176 TOOLCHAIN_DESCRIPTION_clang="clang/LLVM"
4177 TOOLCHAIN_DESCRIPTION_gcc="GNU Compiler Collection"
4178 TOOLCHAIN_DESCRIPTION_microsoft="Microsoft Visual Studio"
4179 TOOLCHAIN_DESCRIPTION_solstudio="Oracle Solaris Studio"
4180 TOOLCHAIN_DESCRIPTION_xlc="IBM XL C/C++"
4181 
4182 # Prepare the system so that TOOLCHAIN_CHECK_COMPILER_VERSION can be called.
4183 # Must have CC_VERSION_NUMBER and CXX_VERSION_NUMBER.
4184 # $1 - optional variable prefix for compiler and version variables (BUILD_)
4185 # $2 - optional variable prefix for comparable variable (OPENJDK_BUILD_)
4186 
4187 
4188 # Check if the configured compiler (C and C++) is of a specific version or
4189 # newer. TOOLCHAIN_PREPARE_FOR_VERSION_COMPARISONS must have been called before.
4190 #
4191 # Arguments:
4192 #   $1:   The version string to check against the found version
4193 #   $2:   block to run if the compiler is at least this version (>=)
4194 #   $3:   block to run if the compiler is older than this version (<)
4195 
4196 
4197 
4198 # Setup a number of variables describing how native output files are
4199 # named on this platform/toolchain.
4200 
4201 
4202 # Determine which toolchain type to use, and make sure it is valid for this
4203 # platform. Setup various information about the selected toolchain.
4204 
4205 
4206 # Before we start detecting the toolchain executables, we might need some
4207 # special setup, e.g. additional paths etc.
4208 
4209 
4210 # Restore path, etc
4211 
4212 
4213 # Check if a compiler is of the toolchain type we expect, and save the version
4214 # information from it. If the compiler does not match the expected type,
4215 # this function will abort using AC_MSG_ERROR. If it matches, the version will
4216 # be stored in CC_VERSION_NUMBER/CXX_VERSION_NUMBER (as a dotted number), and
4217 # the full version string in CC_VERSION_STRING/CXX_VERSION_STRING.
4218 #
4219 # $1 = compiler to test (CC or CXX)
4220 # $2 = human readable name of compiler (C or C++)
4221 
4222 
4223 
4224 # Try to locate the given C or C++ compiler in the path, or otherwise.
4225 #
4226 # $1 = compiler to test (CC or CXX)
4227 # $2 = human readable name of compiler (C or C++)
4228 # $3 = list of compiler names to search for
4229 
4230 
4231 # Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
4232 # preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
4233 # archiver (AR). Verify that the compilers are correct according to the
4234 # toolchain type.
4235 
4236 
4237 # Setup additional tools that is considered a part of the toolchain, but not the
4238 # core part. Many of these are highly platform-specific and do not exist,
4239 # and/or are not needed on all platforms.
4240 
4241 
4242 # Setup the build tools (i.e, the compiler and linker used to build programs
4243 # that should be run on the build platform, not the target platform, as a build
4244 # helper). Since the non-cross-compile case uses the normal, target compilers
4245 # for this, we can only do this after these have been setup.
4246 
4247 
4248 # Setup legacy variables that are still needed as alternative ways to refer to
4249 # parts of the toolchain.
4250 
4251 
4252 # Do some additional checks on the detected tools.
4253 
4254 
4255 # Setup the JTReg Regression Test Harness.
4256 
4257 
4258 
4259 #
4260 # Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved.
4261 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4262 #
4263 # This code is free software; you can redistribute it and/or modify it
4264 # under the terms of the GNU General Public License version 2 only, as
4265 # published by the Free Software Foundation.  Oracle designates this
4266 # particular file as subject to the "Classpath" exception as provided
4267 # by Oracle in the LICENSE file that accompanied this code.
4268 #
4269 # This code is distributed in the hope that it will be useful, but WITHOUT
4270 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4271 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4272 # version 2 for more details (a copy is included in the LICENSE file that
4273 # accompanied this code).
4274 #
4275 # You should have received a copy of the GNU General Public License version
4276 # 2 along with this work; if not, write to the Free Software Foundation,
4277 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4278 #
4279 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4280 # or visit www.oracle.com if you need additional information or have any
4281 # questions.
4282 #
4283 
4284 ################################################################################
4285 # The order of these defines the priority by which we try to find them.
4286 VALID_VS_VERSIONS="2010 2012 2013 2015 2017"
4287 
4288 VS_DESCRIPTION_2010="Microsoft Visual Studio 2010"
4289 VS_VERSION_INTERNAL_2010=100
4290 VS_MSVCR_2010=msvcr100.dll
4291 # We don't use msvcp on Visual Studio 2010
4292 #VS_MSVCP_2010=msvcp100.dll
4293 VS_ENVVAR_2010="VS100COMNTOOLS"
4294 VS_VS_INSTALLDIR_2010="Microsoft Visual Studio 10.0"
4295 VS_SDK_INSTALLDIR_2010="Microsoft SDKs/Windows/v7.1"
4296 VS_VS_PLATFORM_NAME_2010="v100"
4297 VS_SDK_PLATFORM_NAME_2010="Windows7.1SDK"
4298 
4299 VS_DESCRIPTION_2012="Microsoft Visual Studio 2012"
4300 VS_VERSION_INTERNAL_2012=110
4301 VS_MSVCR_2012=msvcr110.dll
4302 VS_MSVCP_2012=msvcp110.dll
4303 VS_ENVVAR_2012="VS110COMNTOOLS"
4304 VS_VS_INSTALLDIR_2012="Microsoft Visual Studio 11.0"
4305 VS_SDK_INSTALLDIR_2012=
4306 VS_VS_PLATFORM_NAME_2012="v110"
4307 VS_SDK_PLATFORM_NAME_2012=
4308 
4309 VS_DESCRIPTION_2013="Microsoft Visual Studio 2013"
4310 VS_VERSION_INTERNAL_2013=120
4311 VS_MSVCR_2013=msvcr120.dll
4312 VS_MSVCP_2013=msvcp120.dll
4313 VS_ENVVAR_2013="VS120COMNTOOLS"
4314 VS_VS_INSTALLDIR_2013="Microsoft Visual Studio 12.0"
4315 VS_SDK_INSTALLDIR_2013=
4316 VS_VS_PLATFORM_NAME_2013="v120"
4317 VS_SDK_PLATFORM_NAME_2013=
4318 
4319 VS_DESCRIPTION_2015="Microsoft Visual Studio 2015 - CURRENTLY NOT WORKING"
4320 VS_VERSION_INTERNAL_2015=140
4321 VS_MSVCR_2015=vcruntime140.dll
4322 VS_MSVCP_2015=msvcp140.dll
4323 VS_ENVVAR_2015="VS140COMNTOOLS"
4324 VS_VS_INSTALLDIR_2015="Microsoft Visual Studio 14.0"
4325 VS_SDK_INSTALLDIR_2015=
4326 VS_VS_PLATFORM_NAME_2015="v140"
4327 VS_SDK_PLATFORM_NAME_2015=
4328 # The vcvars of 2015 breaks if 2017 is also installed. Work around this by
4329 # explicitly specifying Windows Kit 8.1 to be used.
4330 VS_ENV_ARGS_2015="8.1"
4331 
4332 VS_DESCRIPTION_2017="Microsoft Visual Studio 2017 - CURRENTLY NOT WORKING"
4333 VS_VERSION_INTERNAL_2017=141
4334 VS_MSVCR_2017=vcruntime140.dll
4335 VS_MSVCP_2017=msvcp140.dll
4336 VS_ENVVAR_2017="VS150COMNTOOLS"
4337 VS_USE_UCRT_2017="true"
4338 VS_VS_INSTALLDIR_2017="Microsoft Visual Studio/2017"
4339 VS_EDITIONS_2017="Community Professional Enterprise"
4340 VS_SDK_INSTALLDIR_2017=
4341 VS_VS_PLATFORM_NAME_2017="v141"
4342 VS_SDK_PLATFORM_NAME_2017=
4343 
4344 ################################################################################
4345 
4346 
4347 
4348 ################################################################################
4349 
4350 
4351 
4352 ################################################################################
4353 # Finds the bat or cmd file in Visual Studio or the SDK that sets up a proper
4354 # build environment and assigns it to VS_ENV_CMD
4355 
4356 
4357 ################################################################################
4358 
4359 
4360 
4361 ################################################################################
4362 # Check if the VS env variables were setup prior to running configure.
4363 # If not, then find vcvarsall.bat and run it automatically, and integrate
4364 # the set env variables into the spec file.
4365 
4366 
4367 
4368 
4369 
4370 
4371 
4372 
4373 
4374 
4375 
4376 
4377 
4378 
4379 # This line needs to be here, verbatim, after all includes and the dummy hook
4380 # definitions. It is replaced with custom functionality when building
4381 # custom sources.
4382 #CUSTOM_AUTOCONF_INCLUDE
4383 
4384 # Do not change or remove the following line, it is needed for consistency checks:
4385 DATE_WHEN_GENERATED=1620850472
4386 
4387 ###############################################################################
4388 #
4389 # Initialization / Boot-strapping
4390 #
4391 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4392 # thus it jumps back and forth, each time gaining something needed later on.
4393 #
4394 ###############################################################################
4395 
4396 # If we are requested to print additional help, do that and then exit.
4397 # This must be the very first call.
4398 
4399   if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4400     $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4401     $PRINTF "Which are valid to use depends on the build platform.\n"
4402     for toolchain in $VALID_TOOLCHAINS_all; do
4403       # Use indirect variable referencing
4404       toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4405       TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
4406       $PRINTF "  %-10s  %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
4407     done
4408 
4409     # And now exit directly
4410     exit 0
4411   fi
4412 
4413 
4414 # Basic initialization that must happen first of all in the normal process.
4415 
4416   # Save the original command line. This is passed to us by the wrapper configure script.
4417 
4418   DATE_WHEN_CONFIGURED=`LANG=C date`
4419 
4420   { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
4421 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
4422   { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
4423 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
4424 
4425 
4426   # Start with tools that do not need have cross compilation support
4427   # and can be expected to be found in the default PATH. These tools are
4428   # used by configure. Nor are these tools expected to be found in the
4429   # devkit from the builddeps server either, since they are
4430   # needed to download the devkit.
4431 
4432   # First are all the simple required tools.
4433 
4434 
4435 
4436   # Publish this variable in the help.
4437 
4438 
4439   if test "x$BASENAME" = x; then
4440     # The variable is not set by user, try to locate tool using the code snippet
4441     for ac_prog in basename
4442 do
4443   # Extract the first word of "$ac_prog", so it can be a program name with args.
4444 set dummy $ac_prog; ac_word=$2
4445 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4446 $as_echo_n "checking for $ac_word... " >&6; }
4447 if ${ac_cv_path_BASENAME+:} false; then :
4448   $as_echo_n "(cached) " >&6
4449 else
4450   case $BASENAME in
4451   [\\/]* | ?:[\\/]*)
4452   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4453   ;;
4454   *)
4455   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4456 for as_dir in $PATH
4457 do
4458   IFS=$as_save_IFS
4459   test -z "$as_dir" && as_dir=.
4460     for ac_exec_ext in '' $ac_executable_extensions; do
4461   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4462     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4463     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4464     break 2
4465   fi
4466 done
4467   done
4468 IFS=$as_save_IFS
4469 
4470   ;;
4471 esac
4472 fi
4473 BASENAME=$ac_cv_path_BASENAME
4474 if test -n "$BASENAME"; then
4475   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4476 $as_echo "$BASENAME" >&6; }
4477 else
4478   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4479 $as_echo "no" >&6; }
4480 fi
4481 
4482 
4483   test -n "$BASENAME" && break
4484 done
4485 
4486   else
4487     # The variable is set, but is it from the command line or the environment?
4488 
4489     # Try to remove the string !BASENAME! from our list.
4490     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
4491     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4492       # If it failed, the variable was not from the command line. Ignore it,
4493       # but warn the user (except for BASH, which is always set by the calling BASH).
4494       if test "xBASENAME" != xBASH; then
4495         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
4496 $as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
4497       fi
4498       # Try to locate tool using the code snippet
4499       for ac_prog in basename
4500 do
4501   # Extract the first word of "$ac_prog", so it can be a program name with args.
4502 set dummy $ac_prog; ac_word=$2
4503 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4504 $as_echo_n "checking for $ac_word... " >&6; }
4505 if ${ac_cv_path_BASENAME+:} false; then :
4506   $as_echo_n "(cached) " >&6
4507 else
4508   case $BASENAME in
4509   [\\/]* | ?:[\\/]*)
4510   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4511   ;;
4512   *)
4513   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4514 for as_dir in $PATH
4515 do
4516   IFS=$as_save_IFS
4517   test -z "$as_dir" && as_dir=.
4518     for ac_exec_ext in '' $ac_executable_extensions; do
4519   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4520     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4521     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4522     break 2
4523   fi
4524 done
4525   done
4526 IFS=$as_save_IFS
4527 
4528   ;;
4529 esac
4530 fi
4531 BASENAME=$ac_cv_path_BASENAME
4532 if test -n "$BASENAME"; then
4533   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4534 $as_echo "$BASENAME" >&6; }
4535 else
4536   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4537 $as_echo "no" >&6; }
4538 fi
4539 
4540 
4541   test -n "$BASENAME" && break
4542 done
4543 
4544     else
4545       # If it succeeded, then it was overridden by the user. We will use it
4546       # for the tool.
4547 
4548       # First remove it from the list of overridden variables, so we can test
4549       # for unknown variables in the end.
4550       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4551 
4552       # Check if the provided tool contains a complete path.
4553       tool_specified="$BASENAME"
4554       tool_basename="${tool_specified##*/}"
4555       if test "x$tool_basename" = "x$tool_specified"; then
4556         # A command without a complete path is provided, search $PATH.
4557         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
4558 $as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
4559         # Extract the first word of "$tool_basename", so it can be a program name with args.
4560 set dummy $tool_basename; ac_word=$2
4561 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4562 $as_echo_n "checking for $ac_word... " >&6; }
4563 if ${ac_cv_path_BASENAME+:} false; then :
4564   $as_echo_n "(cached) " >&6
4565 else
4566   case $BASENAME in
4567   [\\/]* | ?:[\\/]*)
4568   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4569   ;;
4570   *)
4571   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4572 for as_dir in $PATH
4573 do
4574   IFS=$as_save_IFS
4575   test -z "$as_dir" && as_dir=.
4576     for ac_exec_ext in '' $ac_executable_extensions; do
4577   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4578     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4579     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4580     break 2
4581   fi
4582 done
4583   done
4584 IFS=$as_save_IFS
4585 
4586   ;;
4587 esac
4588 fi
4589 BASENAME=$ac_cv_path_BASENAME
4590 if test -n "$BASENAME"; then
4591   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4592 $as_echo "$BASENAME" >&6; }
4593 else
4594   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4595 $as_echo "no" >&6; }
4596 fi
4597 
4598 
4599         if test "x$BASENAME" = x; then
4600           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4601         fi
4602       else
4603         # Otherwise we believe it is a complete path. Use it as it is.
4604         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
4605 $as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
4606         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
4607 $as_echo_n "checking for BASENAME... " >&6; }
4608         if test ! -x "$tool_specified"; then
4609           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4610 $as_echo "not found" >&6; }
4611           as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
4612         fi
4613         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4614 $as_echo "$tool_specified" >&6; }
4615       fi
4616     fi
4617   fi
4618 
4619 
4620 
4621   if test "x$BASENAME" = x; then
4622     as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
4623   fi
4624 
4625 
4626 
4627 
4628 
4629   # Publish this variable in the help.
4630 
4631 
4632   if test "x$BASH" = x; then
4633     # The variable is not set by user, try to locate tool using the code snippet
4634     for ac_prog in bash
4635 do
4636   # Extract the first word of "$ac_prog", so it can be a program name with args.
4637 set dummy $ac_prog; ac_word=$2
4638 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4639 $as_echo_n "checking for $ac_word... " >&6; }
4640 if ${ac_cv_path_BASH+:} false; then :
4641   $as_echo_n "(cached) " >&6
4642 else
4643   case $BASH in
4644   [\\/]* | ?:[\\/]*)
4645   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4646   ;;
4647   *)
4648   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4649 for as_dir in $PATH
4650 do
4651   IFS=$as_save_IFS
4652   test -z "$as_dir" && as_dir=.
4653     for ac_exec_ext in '' $ac_executable_extensions; do
4654   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4655     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4656     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4657     break 2
4658   fi
4659 done
4660   done
4661 IFS=$as_save_IFS
4662 
4663   ;;
4664 esac
4665 fi
4666 BASH=$ac_cv_path_BASH
4667 if test -n "$BASH"; then
4668   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4669 $as_echo "$BASH" >&6; }
4670 else
4671   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4672 $as_echo "no" >&6; }
4673 fi
4674 
4675 
4676   test -n "$BASH" && break
4677 done
4678 
4679   else
4680     # The variable is set, but is it from the command line or the environment?
4681 
4682     # Try to remove the string !BASH! from our list.
4683     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
4684     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4685       # If it failed, the variable was not from the command line. Ignore it,
4686       # but warn the user (except for BASH, which is always set by the calling BASH).
4687       if test "xBASH" != xBASH; then
4688         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
4689 $as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
4690       fi
4691       # Try to locate tool using the code snippet
4692       for ac_prog in bash
4693 do
4694   # Extract the first word of "$ac_prog", so it can be a program name with args.
4695 set dummy $ac_prog; ac_word=$2
4696 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4697 $as_echo_n "checking for $ac_word... " >&6; }
4698 if ${ac_cv_path_BASH+:} false; then :
4699   $as_echo_n "(cached) " >&6
4700 else
4701   case $BASH in
4702   [\\/]* | ?:[\\/]*)
4703   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4704   ;;
4705   *)
4706   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4707 for as_dir in $PATH
4708 do
4709   IFS=$as_save_IFS
4710   test -z "$as_dir" && as_dir=.
4711     for ac_exec_ext in '' $ac_executable_extensions; do
4712   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4713     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4714     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4715     break 2
4716   fi
4717 done
4718   done
4719 IFS=$as_save_IFS
4720 
4721   ;;
4722 esac
4723 fi
4724 BASH=$ac_cv_path_BASH
4725 if test -n "$BASH"; then
4726   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4727 $as_echo "$BASH" >&6; }
4728 else
4729   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4730 $as_echo "no" >&6; }
4731 fi
4732 
4733 
4734   test -n "$BASH" && break
4735 done
4736 
4737     else
4738       # If it succeeded, then it was overridden by the user. We will use it
4739       # for the tool.
4740 
4741       # First remove it from the list of overridden variables, so we can test
4742       # for unknown variables in the end.
4743       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4744 
4745       # Check if the provided tool contains a complete path.
4746       tool_specified="$BASH"
4747       tool_basename="${tool_specified##*/}"
4748       if test "x$tool_basename" = "x$tool_specified"; then
4749         # A command without a complete path is provided, search $PATH.
4750         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
4751 $as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
4752         # Extract the first word of "$tool_basename", so it can be a program name with args.
4753 set dummy $tool_basename; ac_word=$2
4754 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4755 $as_echo_n "checking for $ac_word... " >&6; }
4756 if ${ac_cv_path_BASH+:} false; then :
4757   $as_echo_n "(cached) " >&6
4758 else
4759   case $BASH in
4760   [\\/]* | ?:[\\/]*)
4761   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4762   ;;
4763   *)
4764   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4765 for as_dir in $PATH
4766 do
4767   IFS=$as_save_IFS
4768   test -z "$as_dir" && as_dir=.
4769     for ac_exec_ext in '' $ac_executable_extensions; do
4770   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4771     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4772     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4773     break 2
4774   fi
4775 done
4776   done
4777 IFS=$as_save_IFS
4778 
4779   ;;
4780 esac
4781 fi
4782 BASH=$ac_cv_path_BASH
4783 if test -n "$BASH"; then
4784   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4785 $as_echo "$BASH" >&6; }
4786 else
4787   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4788 $as_echo "no" >&6; }
4789 fi
4790 
4791 
4792         if test "x$BASH" = x; then
4793           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4794         fi
4795       else
4796         # Otherwise we believe it is a complete path. Use it as it is.
4797         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
4798 $as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
4799         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
4800 $as_echo_n "checking for BASH... " >&6; }
4801         if test ! -x "$tool_specified"; then
4802           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4803 $as_echo "not found" >&6; }
4804           as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
4805         fi
4806         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4807 $as_echo "$tool_specified" >&6; }
4808       fi
4809     fi
4810   fi
4811 
4812 
4813 
4814   if test "x$BASH" = x; then
4815     as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
4816   fi
4817 
4818 
4819 
4820 
4821 
4822   # Publish this variable in the help.
4823 
4824 
4825   if test "x$CAT" = x; then
4826     # The variable is not set by user, try to locate tool using the code snippet
4827     for ac_prog in cat
4828 do
4829   # Extract the first word of "$ac_prog", so it can be a program name with args.
4830 set dummy $ac_prog; ac_word=$2
4831 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4832 $as_echo_n "checking for $ac_word... " >&6; }
4833 if ${ac_cv_path_CAT+:} false; then :
4834   $as_echo_n "(cached) " >&6
4835 else
4836   case $CAT in
4837   [\\/]* | ?:[\\/]*)
4838   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4839   ;;
4840   *)
4841   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4842 for as_dir in $PATH
4843 do
4844   IFS=$as_save_IFS
4845   test -z "$as_dir" && as_dir=.
4846     for ac_exec_ext in '' $ac_executable_extensions; do
4847   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4848     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4849     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4850     break 2
4851   fi
4852 done
4853   done
4854 IFS=$as_save_IFS
4855 
4856   ;;
4857 esac
4858 fi
4859 CAT=$ac_cv_path_CAT
4860 if test -n "$CAT"; then
4861   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4862 $as_echo "$CAT" >&6; }
4863 else
4864   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4865 $as_echo "no" >&6; }
4866 fi
4867 
4868 
4869   test -n "$CAT" && break
4870 done
4871 
4872   else
4873     # The variable is set, but is it from the command line or the environment?
4874 
4875     # Try to remove the string !CAT! from our list.
4876     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
4877     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4878       # If it failed, the variable was not from the command line. Ignore it,
4879       # but warn the user (except for BASH, which is always set by the calling BASH).
4880       if test "xCAT" != xBASH; then
4881         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
4882 $as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
4883       fi
4884       # Try to locate tool using the code snippet
4885       for ac_prog in cat
4886 do
4887   # Extract the first word of "$ac_prog", so it can be a program name with args.
4888 set dummy $ac_prog; ac_word=$2
4889 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4890 $as_echo_n "checking for $ac_word... " >&6; }
4891 if ${ac_cv_path_CAT+:} false; then :
4892   $as_echo_n "(cached) " >&6
4893 else
4894   case $CAT in
4895   [\\/]* | ?:[\\/]*)
4896   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4897   ;;
4898   *)
4899   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4900 for as_dir in $PATH
4901 do
4902   IFS=$as_save_IFS
4903   test -z "$as_dir" && as_dir=.
4904     for ac_exec_ext in '' $ac_executable_extensions; do
4905   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4906     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4907     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4908     break 2
4909   fi
4910 done
4911   done
4912 IFS=$as_save_IFS
4913 
4914   ;;
4915 esac
4916 fi
4917 CAT=$ac_cv_path_CAT
4918 if test -n "$CAT"; then
4919   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4920 $as_echo "$CAT" >&6; }
4921 else
4922   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4923 $as_echo "no" >&6; }
4924 fi
4925 
4926 
4927   test -n "$CAT" && break
4928 done
4929 
4930     else
4931       # If it succeeded, then it was overridden by the user. We will use it
4932       # for the tool.
4933 
4934       # First remove it from the list of overridden variables, so we can test
4935       # for unknown variables in the end.
4936       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4937 
4938       # Check if the provided tool contains a complete path.
4939       tool_specified="$CAT"
4940       tool_basename="${tool_specified##*/}"
4941       if test "x$tool_basename" = "x$tool_specified"; then
4942         # A command without a complete path is provided, search $PATH.
4943         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
4944 $as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
4945         # Extract the first word of "$tool_basename", so it can be a program name with args.
4946 set dummy $tool_basename; ac_word=$2
4947 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4948 $as_echo_n "checking for $ac_word... " >&6; }
4949 if ${ac_cv_path_CAT+:} false; then :
4950   $as_echo_n "(cached) " >&6
4951 else
4952   case $CAT in
4953   [\\/]* | ?:[\\/]*)
4954   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4955   ;;
4956   *)
4957   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4958 for as_dir in $PATH
4959 do
4960   IFS=$as_save_IFS
4961   test -z "$as_dir" && as_dir=.
4962     for ac_exec_ext in '' $ac_executable_extensions; do
4963   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4964     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4965     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4966     break 2
4967   fi
4968 done
4969   done
4970 IFS=$as_save_IFS
4971 
4972   ;;
4973 esac
4974 fi
4975 CAT=$ac_cv_path_CAT
4976 if test -n "$CAT"; then
4977   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4978 $as_echo "$CAT" >&6; }
4979 else
4980   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4981 $as_echo "no" >&6; }
4982 fi
4983 
4984 
4985         if test "x$CAT" = x; then
4986           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4987         fi
4988       else
4989         # Otherwise we believe it is a complete path. Use it as it is.
4990         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
4991 $as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
4992         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
4993 $as_echo_n "checking for CAT... " >&6; }
4994         if test ! -x "$tool_specified"; then
4995           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4996 $as_echo "not found" >&6; }
4997           as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
4998         fi
4999         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5000 $as_echo "$tool_specified" >&6; }
5001       fi
5002     fi
5003   fi
5004 
5005 
5006 
5007   if test "x$CAT" = x; then
5008     as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
5009   fi
5010 
5011 
5012 
5013 
5014 
5015   # Publish this variable in the help.
5016 
5017 
5018   if test "x$CHMOD" = x; then
5019     # The variable is not set by user, try to locate tool using the code snippet
5020     for ac_prog in chmod
5021 do
5022   # Extract the first word of "$ac_prog", so it can be a program name with args.
5023 set dummy $ac_prog; ac_word=$2
5024 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5025 $as_echo_n "checking for $ac_word... " >&6; }
5026 if ${ac_cv_path_CHMOD+:} false; then :
5027   $as_echo_n "(cached) " >&6
5028 else
5029   case $CHMOD in
5030   [\\/]* | ?:[\\/]*)
5031   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5032   ;;
5033   *)
5034   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5035 for as_dir in $PATH
5036 do
5037   IFS=$as_save_IFS
5038   test -z "$as_dir" && as_dir=.
5039     for ac_exec_ext in '' $ac_executable_extensions; do
5040   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5041     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5042     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5043     break 2
5044   fi
5045 done
5046   done
5047 IFS=$as_save_IFS
5048 
5049   ;;
5050 esac
5051 fi
5052 CHMOD=$ac_cv_path_CHMOD
5053 if test -n "$CHMOD"; then
5054   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5055 $as_echo "$CHMOD" >&6; }
5056 else
5057   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5058 $as_echo "no" >&6; }
5059 fi
5060 
5061 
5062   test -n "$CHMOD" && break
5063 done
5064 
5065   else
5066     # The variable is set, but is it from the command line or the environment?
5067 
5068     # Try to remove the string !CHMOD! from our list.
5069     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
5070     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5071       # If it failed, the variable was not from the command line. Ignore it,
5072       # but warn the user (except for BASH, which is always set by the calling BASH).
5073       if test "xCHMOD" != xBASH; then
5074         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
5075 $as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
5076       fi
5077       # Try to locate tool using the code snippet
5078       for ac_prog in chmod
5079 do
5080   # Extract the first word of "$ac_prog", so it can be a program name with args.
5081 set dummy $ac_prog; ac_word=$2
5082 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5083 $as_echo_n "checking for $ac_word... " >&6; }
5084 if ${ac_cv_path_CHMOD+:} false; then :
5085   $as_echo_n "(cached) " >&6
5086 else
5087   case $CHMOD in
5088   [\\/]* | ?:[\\/]*)
5089   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5090   ;;
5091   *)
5092   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5093 for as_dir in $PATH
5094 do
5095   IFS=$as_save_IFS
5096   test -z "$as_dir" && as_dir=.
5097     for ac_exec_ext in '' $ac_executable_extensions; do
5098   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5099     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5100     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5101     break 2
5102   fi
5103 done
5104   done
5105 IFS=$as_save_IFS
5106 
5107   ;;
5108 esac
5109 fi
5110 CHMOD=$ac_cv_path_CHMOD
5111 if test -n "$CHMOD"; then
5112   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5113 $as_echo "$CHMOD" >&6; }
5114 else
5115   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5116 $as_echo "no" >&6; }
5117 fi
5118 
5119 
5120   test -n "$CHMOD" && break
5121 done
5122 
5123     else
5124       # If it succeeded, then it was overridden by the user. We will use it
5125       # for the tool.
5126 
5127       # First remove it from the list of overridden variables, so we can test
5128       # for unknown variables in the end.
5129       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5130 
5131       # Check if the provided tool contains a complete path.
5132       tool_specified="$CHMOD"
5133       tool_basename="${tool_specified##*/}"
5134       if test "x$tool_basename" = "x$tool_specified"; then
5135         # A command without a complete path is provided, search $PATH.
5136         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
5137 $as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
5138         # Extract the first word of "$tool_basename", so it can be a program name with args.
5139 set dummy $tool_basename; ac_word=$2
5140 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5141 $as_echo_n "checking for $ac_word... " >&6; }
5142 if ${ac_cv_path_CHMOD+:} false; then :
5143   $as_echo_n "(cached) " >&6
5144 else
5145   case $CHMOD in
5146   [\\/]* | ?:[\\/]*)
5147   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5148   ;;
5149   *)
5150   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5151 for as_dir in $PATH
5152 do
5153   IFS=$as_save_IFS
5154   test -z "$as_dir" && as_dir=.
5155     for ac_exec_ext in '' $ac_executable_extensions; do
5156   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5157     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5158     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5159     break 2
5160   fi
5161 done
5162   done
5163 IFS=$as_save_IFS
5164 
5165   ;;
5166 esac
5167 fi
5168 CHMOD=$ac_cv_path_CHMOD
5169 if test -n "$CHMOD"; then
5170   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5171 $as_echo "$CHMOD" >&6; }
5172 else
5173   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5174 $as_echo "no" >&6; }
5175 fi
5176 
5177 
5178         if test "x$CHMOD" = x; then
5179           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5180         fi
5181       else
5182         # Otherwise we believe it is a complete path. Use it as it is.
5183         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
5184 $as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
5185         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5186 $as_echo_n "checking for CHMOD... " >&6; }
5187         if test ! -x "$tool_specified"; then
5188           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5189 $as_echo "not found" >&6; }
5190           as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
5191         fi
5192         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5193 $as_echo "$tool_specified" >&6; }
5194       fi
5195     fi
5196   fi
5197 
5198 
5199 
5200   if test "x$CHMOD" = x; then
5201     as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
5202   fi
5203 
5204 
5205 
5206 
5207 
5208   # Publish this variable in the help.
5209 
5210 
5211   if test "x$CMP" = x; then
5212     # The variable is not set by user, try to locate tool using the code snippet
5213     for ac_prog in cmp
5214 do
5215   # Extract the first word of "$ac_prog", so it can be a program name with args.
5216 set dummy $ac_prog; ac_word=$2
5217 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5218 $as_echo_n "checking for $ac_word... " >&6; }
5219 if ${ac_cv_path_CMP+:} false; then :
5220   $as_echo_n "(cached) " >&6
5221 else
5222   case $CMP in
5223   [\\/]* | ?:[\\/]*)
5224   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5225   ;;
5226   *)
5227   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5228 for as_dir in $PATH
5229 do
5230   IFS=$as_save_IFS
5231   test -z "$as_dir" && as_dir=.
5232     for ac_exec_ext in '' $ac_executable_extensions; do
5233   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5234     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5235     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5236     break 2
5237   fi
5238 done
5239   done
5240 IFS=$as_save_IFS
5241 
5242   ;;
5243 esac
5244 fi
5245 CMP=$ac_cv_path_CMP
5246 if test -n "$CMP"; then
5247   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5248 $as_echo "$CMP" >&6; }
5249 else
5250   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5251 $as_echo "no" >&6; }
5252 fi
5253 
5254 
5255   test -n "$CMP" && break
5256 done
5257 
5258   else
5259     # The variable is set, but is it from the command line or the environment?
5260 
5261     # Try to remove the string !CMP! from our list.
5262     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
5263     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5264       # If it failed, the variable was not from the command line. Ignore it,
5265       # but warn the user (except for BASH, which is always set by the calling BASH).
5266       if test "xCMP" != xBASH; then
5267         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
5268 $as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
5269       fi
5270       # Try to locate tool using the code snippet
5271       for ac_prog in cmp
5272 do
5273   # Extract the first word of "$ac_prog", so it can be a program name with args.
5274 set dummy $ac_prog; ac_word=$2
5275 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5276 $as_echo_n "checking for $ac_word... " >&6; }
5277 if ${ac_cv_path_CMP+:} false; then :
5278   $as_echo_n "(cached) " >&6
5279 else
5280   case $CMP in
5281   [\\/]* | ?:[\\/]*)
5282   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5283   ;;
5284   *)
5285   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5286 for as_dir in $PATH
5287 do
5288   IFS=$as_save_IFS
5289   test -z "$as_dir" && as_dir=.
5290     for ac_exec_ext in '' $ac_executable_extensions; do
5291   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5292     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5293     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5294     break 2
5295   fi
5296 done
5297   done
5298 IFS=$as_save_IFS
5299 
5300   ;;
5301 esac
5302 fi
5303 CMP=$ac_cv_path_CMP
5304 if test -n "$CMP"; then
5305   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5306 $as_echo "$CMP" >&6; }
5307 else
5308   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5309 $as_echo "no" >&6; }
5310 fi
5311 
5312 
5313   test -n "$CMP" && break
5314 done
5315 
5316     else
5317       # If it succeeded, then it was overridden by the user. We will use it
5318       # for the tool.
5319 
5320       # First remove it from the list of overridden variables, so we can test
5321       # for unknown variables in the end.
5322       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5323 
5324       # Check if the provided tool contains a complete path.
5325       tool_specified="$CMP"
5326       tool_basename="${tool_specified##*/}"
5327       if test "x$tool_basename" = "x$tool_specified"; then
5328         # A command without a complete path is provided, search $PATH.
5329         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
5330 $as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
5331         # Extract the first word of "$tool_basename", so it can be a program name with args.
5332 set dummy $tool_basename; ac_word=$2
5333 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5334 $as_echo_n "checking for $ac_word... " >&6; }
5335 if ${ac_cv_path_CMP+:} false; then :
5336   $as_echo_n "(cached) " >&6
5337 else
5338   case $CMP in
5339   [\\/]* | ?:[\\/]*)
5340   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5341   ;;
5342   *)
5343   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5344 for as_dir in $PATH
5345 do
5346   IFS=$as_save_IFS
5347   test -z "$as_dir" && as_dir=.
5348     for ac_exec_ext in '' $ac_executable_extensions; do
5349   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5350     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5351     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5352     break 2
5353   fi
5354 done
5355   done
5356 IFS=$as_save_IFS
5357 
5358   ;;
5359 esac
5360 fi
5361 CMP=$ac_cv_path_CMP
5362 if test -n "$CMP"; then
5363   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5364 $as_echo "$CMP" >&6; }
5365 else
5366   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5367 $as_echo "no" >&6; }
5368 fi
5369 
5370 
5371         if test "x$CMP" = x; then
5372           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5373         fi
5374       else
5375         # Otherwise we believe it is a complete path. Use it as it is.
5376         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
5377 $as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
5378         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
5379 $as_echo_n "checking for CMP... " >&6; }
5380         if test ! -x "$tool_specified"; then
5381           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5382 $as_echo "not found" >&6; }
5383           as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
5384         fi
5385         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5386 $as_echo "$tool_specified" >&6; }
5387       fi
5388     fi
5389   fi
5390 
5391 
5392 
5393   if test "x$CMP" = x; then
5394     as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
5395   fi
5396 
5397 
5398 
5399 
5400 
5401   # Publish this variable in the help.
5402 
5403 
5404   if test "x$COMM" = x; then
5405     # The variable is not set by user, try to locate tool using the code snippet
5406     for ac_prog in comm
5407 do
5408   # Extract the first word of "$ac_prog", so it can be a program name with args.
5409 set dummy $ac_prog; ac_word=$2
5410 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5411 $as_echo_n "checking for $ac_word... " >&6; }
5412 if ${ac_cv_path_COMM+:} false; then :
5413   $as_echo_n "(cached) " >&6
5414 else
5415   case $COMM in
5416   [\\/]* | ?:[\\/]*)
5417   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5418   ;;
5419   *)
5420   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5421 for as_dir in $PATH
5422 do
5423   IFS=$as_save_IFS
5424   test -z "$as_dir" && as_dir=.
5425     for ac_exec_ext in '' $ac_executable_extensions; do
5426   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5427     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5428     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5429     break 2
5430   fi
5431 done
5432   done
5433 IFS=$as_save_IFS
5434 
5435   ;;
5436 esac
5437 fi
5438 COMM=$ac_cv_path_COMM
5439 if test -n "$COMM"; then
5440   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5441 $as_echo "$COMM" >&6; }
5442 else
5443   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5444 $as_echo "no" >&6; }
5445 fi
5446 
5447 
5448   test -n "$COMM" && break
5449 done
5450 
5451   else
5452     # The variable is set, but is it from the command line or the environment?
5453 
5454     # Try to remove the string !COMM! from our list.
5455     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
5456     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5457       # If it failed, the variable was not from the command line. Ignore it,
5458       # but warn the user (except for BASH, which is always set by the calling BASH).
5459       if test "xCOMM" != xBASH; then
5460         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
5461 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
5462       fi
5463       # Try to locate tool using the code snippet
5464       for ac_prog in comm
5465 do
5466   # Extract the first word of "$ac_prog", so it can be a program name with args.
5467 set dummy $ac_prog; ac_word=$2
5468 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5469 $as_echo_n "checking for $ac_word... " >&6; }
5470 if ${ac_cv_path_COMM+:} false; then :
5471   $as_echo_n "(cached) " >&6
5472 else
5473   case $COMM in
5474   [\\/]* | ?:[\\/]*)
5475   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5476   ;;
5477   *)
5478   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5479 for as_dir in $PATH
5480 do
5481   IFS=$as_save_IFS
5482   test -z "$as_dir" && as_dir=.
5483     for ac_exec_ext in '' $ac_executable_extensions; do
5484   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5485     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5486     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5487     break 2
5488   fi
5489 done
5490   done
5491 IFS=$as_save_IFS
5492 
5493   ;;
5494 esac
5495 fi
5496 COMM=$ac_cv_path_COMM
5497 if test -n "$COMM"; then
5498   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5499 $as_echo "$COMM" >&6; }
5500 else
5501   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5502 $as_echo "no" >&6; }
5503 fi
5504 
5505 
5506   test -n "$COMM" && break
5507 done
5508 
5509     else
5510       # If it succeeded, then it was overridden by the user. We will use it
5511       # for the tool.
5512 
5513       # First remove it from the list of overridden variables, so we can test
5514       # for unknown variables in the end.
5515       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5516 
5517       # Check if the provided tool contains a complete path.
5518       tool_specified="$COMM"
5519       tool_basename="${tool_specified##*/}"
5520       if test "x$tool_basename" = "x$tool_specified"; then
5521         # A command without a complete path is provided, search $PATH.
5522         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
5523 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
5524         # Extract the first word of "$tool_basename", so it can be a program name with args.
5525 set dummy $tool_basename; ac_word=$2
5526 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5527 $as_echo_n "checking for $ac_word... " >&6; }
5528 if ${ac_cv_path_COMM+:} false; then :
5529   $as_echo_n "(cached) " >&6
5530 else
5531   case $COMM in
5532   [\\/]* | ?:[\\/]*)
5533   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5534   ;;
5535   *)
5536   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5537 for as_dir in $PATH
5538 do
5539   IFS=$as_save_IFS
5540   test -z "$as_dir" && as_dir=.
5541     for ac_exec_ext in '' $ac_executable_extensions; do
5542   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5543     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5544     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5545     break 2
5546   fi
5547 done
5548   done
5549 IFS=$as_save_IFS
5550 
5551   ;;
5552 esac
5553 fi
5554 COMM=$ac_cv_path_COMM
5555 if test -n "$COMM"; then
5556   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5557 $as_echo "$COMM" >&6; }
5558 else
5559   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5560 $as_echo "no" >&6; }
5561 fi
5562 
5563 
5564         if test "x$COMM" = x; then
5565           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5566         fi
5567       else
5568         # Otherwise we believe it is a complete path. Use it as it is.
5569         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
5570 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
5571         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
5572 $as_echo_n "checking for COMM... " >&6; }
5573         if test ! -x "$tool_specified"; then
5574           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5575 $as_echo "not found" >&6; }
5576           as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
5577         fi
5578         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5579 $as_echo "$tool_specified" >&6; }
5580       fi
5581     fi
5582   fi
5583 
5584 
5585 
5586   if test "x$COMM" = x; then
5587     as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
5588   fi
5589 
5590 
5591 
5592 
5593 
5594   # Publish this variable in the help.
5595 
5596 
5597   if test "x$CP" = x; then
5598     # The variable is not set by user, try to locate tool using the code snippet
5599     for ac_prog in cp
5600 do
5601   # Extract the first word of "$ac_prog", so it can be a program name with args.
5602 set dummy $ac_prog; ac_word=$2
5603 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5604 $as_echo_n "checking for $ac_word... " >&6; }
5605 if ${ac_cv_path_CP+:} false; then :
5606   $as_echo_n "(cached) " >&6
5607 else
5608   case $CP in
5609   [\\/]* | ?:[\\/]*)
5610   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5611   ;;
5612   *)
5613   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5614 for as_dir in $PATH
5615 do
5616   IFS=$as_save_IFS
5617   test -z "$as_dir" && as_dir=.
5618     for ac_exec_ext in '' $ac_executable_extensions; do
5619   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5620     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5621     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5622     break 2
5623   fi
5624 done
5625   done
5626 IFS=$as_save_IFS
5627 
5628   ;;
5629 esac
5630 fi
5631 CP=$ac_cv_path_CP
5632 if test -n "$CP"; then
5633   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5634 $as_echo "$CP" >&6; }
5635 else
5636   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5637 $as_echo "no" >&6; }
5638 fi
5639 
5640 
5641   test -n "$CP" && break
5642 done
5643 
5644   else
5645     # The variable is set, but is it from the command line or the environment?
5646 
5647     # Try to remove the string !CP! from our list.
5648     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
5649     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5650       # If it failed, the variable was not from the command line. Ignore it,
5651       # but warn the user (except for BASH, which is always set by the calling BASH).
5652       if test "xCP" != xBASH; then
5653         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
5654 $as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
5655       fi
5656       # Try to locate tool using the code snippet
5657       for ac_prog in cp
5658 do
5659   # Extract the first word of "$ac_prog", so it can be a program name with args.
5660 set dummy $ac_prog; ac_word=$2
5661 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5662 $as_echo_n "checking for $ac_word... " >&6; }
5663 if ${ac_cv_path_CP+:} false; then :
5664   $as_echo_n "(cached) " >&6
5665 else
5666   case $CP in
5667   [\\/]* | ?:[\\/]*)
5668   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5669   ;;
5670   *)
5671   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5672 for as_dir in $PATH
5673 do
5674   IFS=$as_save_IFS
5675   test -z "$as_dir" && as_dir=.
5676     for ac_exec_ext in '' $ac_executable_extensions; do
5677   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5678     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5679     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5680     break 2
5681   fi
5682 done
5683   done
5684 IFS=$as_save_IFS
5685 
5686   ;;
5687 esac
5688 fi
5689 CP=$ac_cv_path_CP
5690 if test -n "$CP"; then
5691   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5692 $as_echo "$CP" >&6; }
5693 else
5694   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5695 $as_echo "no" >&6; }
5696 fi
5697 
5698 
5699   test -n "$CP" && break
5700 done
5701 
5702     else
5703       # If it succeeded, then it was overridden by the user. We will use it
5704       # for the tool.
5705 
5706       # First remove it from the list of overridden variables, so we can test
5707       # for unknown variables in the end.
5708       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5709 
5710       # Check if the provided tool contains a complete path.
5711       tool_specified="$CP"
5712       tool_basename="${tool_specified##*/}"
5713       if test "x$tool_basename" = "x$tool_specified"; then
5714         # A command without a complete path is provided, search $PATH.
5715         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
5716 $as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
5717         # Extract the first word of "$tool_basename", so it can be a program name with args.
5718 set dummy $tool_basename; ac_word=$2
5719 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5720 $as_echo_n "checking for $ac_word... " >&6; }
5721 if ${ac_cv_path_CP+:} false; then :
5722   $as_echo_n "(cached) " >&6
5723 else
5724   case $CP in
5725   [\\/]* | ?:[\\/]*)
5726   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5727   ;;
5728   *)
5729   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5730 for as_dir in $PATH
5731 do
5732   IFS=$as_save_IFS
5733   test -z "$as_dir" && as_dir=.
5734     for ac_exec_ext in '' $ac_executable_extensions; do
5735   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5736     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5737     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5738     break 2
5739   fi
5740 done
5741   done
5742 IFS=$as_save_IFS
5743 
5744   ;;
5745 esac
5746 fi
5747 CP=$ac_cv_path_CP
5748 if test -n "$CP"; then
5749   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5750 $as_echo "$CP" >&6; }
5751 else
5752   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5753 $as_echo "no" >&6; }
5754 fi
5755 
5756 
5757         if test "x$CP" = x; then
5758           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5759         fi
5760       else
5761         # Otherwise we believe it is a complete path. Use it as it is.
5762         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
5763 $as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
5764         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
5765 $as_echo_n "checking for CP... " >&6; }
5766         if test ! -x "$tool_specified"; then
5767           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5768 $as_echo "not found" >&6; }
5769           as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
5770         fi
5771         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5772 $as_echo "$tool_specified" >&6; }
5773       fi
5774     fi
5775   fi
5776 
5777 
5778 
5779   if test "x$CP" = x; then
5780     as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
5781   fi
5782 
5783 
5784 
5785 
5786 
5787   # Publish this variable in the help.
5788 
5789 
5790   if test "x$CUT" = x; then
5791     # The variable is not set by user, try to locate tool using the code snippet
5792     for ac_prog in cut
5793 do
5794   # Extract the first word of "$ac_prog", so it can be a program name with args.
5795 set dummy $ac_prog; ac_word=$2
5796 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5797 $as_echo_n "checking for $ac_word... " >&6; }
5798 if ${ac_cv_path_CUT+:} false; then :
5799   $as_echo_n "(cached) " >&6
5800 else
5801   case $CUT in
5802   [\\/]* | ?:[\\/]*)
5803   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5804   ;;
5805   *)
5806   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5807 for as_dir in $PATH
5808 do
5809   IFS=$as_save_IFS
5810   test -z "$as_dir" && as_dir=.
5811     for ac_exec_ext in '' $ac_executable_extensions; do
5812   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5813     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5814     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5815     break 2
5816   fi
5817 done
5818   done
5819 IFS=$as_save_IFS
5820 
5821   ;;
5822 esac
5823 fi
5824 CUT=$ac_cv_path_CUT
5825 if test -n "$CUT"; then
5826   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5827 $as_echo "$CUT" >&6; }
5828 else
5829   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5830 $as_echo "no" >&6; }
5831 fi
5832 
5833 
5834   test -n "$CUT" && break
5835 done
5836 
5837   else
5838     # The variable is set, but is it from the command line or the environment?
5839 
5840     # Try to remove the string !CUT! from our list.
5841     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
5842     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5843       # If it failed, the variable was not from the command line. Ignore it,
5844       # but warn the user (except for BASH, which is always set by the calling BASH).
5845       if test "xCUT" != xBASH; then
5846         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
5847 $as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
5848       fi
5849       # Try to locate tool using the code snippet
5850       for ac_prog in cut
5851 do
5852   # Extract the first word of "$ac_prog", so it can be a program name with args.
5853 set dummy $ac_prog; ac_word=$2
5854 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5855 $as_echo_n "checking for $ac_word... " >&6; }
5856 if ${ac_cv_path_CUT+:} false; then :
5857   $as_echo_n "(cached) " >&6
5858 else
5859   case $CUT in
5860   [\\/]* | ?:[\\/]*)
5861   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5862   ;;
5863   *)
5864   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5865 for as_dir in $PATH
5866 do
5867   IFS=$as_save_IFS
5868   test -z "$as_dir" && as_dir=.
5869     for ac_exec_ext in '' $ac_executable_extensions; do
5870   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5871     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5872     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5873     break 2
5874   fi
5875 done
5876   done
5877 IFS=$as_save_IFS
5878 
5879   ;;
5880 esac
5881 fi
5882 CUT=$ac_cv_path_CUT
5883 if test -n "$CUT"; then
5884   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5885 $as_echo "$CUT" >&6; }
5886 else
5887   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5888 $as_echo "no" >&6; }
5889 fi
5890 
5891 
5892   test -n "$CUT" && break
5893 done
5894 
5895     else
5896       # If it succeeded, then it was overridden by the user. We will use it
5897       # for the tool.
5898 
5899       # First remove it from the list of overridden variables, so we can test
5900       # for unknown variables in the end.
5901       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5902 
5903       # Check if the provided tool contains a complete path.
5904       tool_specified="$CUT"
5905       tool_basename="${tool_specified##*/}"
5906       if test "x$tool_basename" = "x$tool_specified"; then
5907         # A command without a complete path is provided, search $PATH.
5908         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
5909 $as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
5910         # Extract the first word of "$tool_basename", so it can be a program name with args.
5911 set dummy $tool_basename; ac_word=$2
5912 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5913 $as_echo_n "checking for $ac_word... " >&6; }
5914 if ${ac_cv_path_CUT+:} false; then :
5915   $as_echo_n "(cached) " >&6
5916 else
5917   case $CUT in
5918   [\\/]* | ?:[\\/]*)
5919   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5920   ;;
5921   *)
5922   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5923 for as_dir in $PATH
5924 do
5925   IFS=$as_save_IFS
5926   test -z "$as_dir" && as_dir=.
5927     for ac_exec_ext in '' $ac_executable_extensions; do
5928   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5929     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5930     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5931     break 2
5932   fi
5933 done
5934   done
5935 IFS=$as_save_IFS
5936 
5937   ;;
5938 esac
5939 fi
5940 CUT=$ac_cv_path_CUT
5941 if test -n "$CUT"; then
5942   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5943 $as_echo "$CUT" >&6; }
5944 else
5945   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5946 $as_echo "no" >&6; }
5947 fi
5948 
5949 
5950         if test "x$CUT" = x; then
5951           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5952         fi
5953       else
5954         # Otherwise we believe it is a complete path. Use it as it is.
5955         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
5956 $as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
5957         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
5958 $as_echo_n "checking for CUT... " >&6; }
5959         if test ! -x "$tool_specified"; then
5960           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5961 $as_echo "not found" >&6; }
5962           as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
5963         fi
5964         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5965 $as_echo "$tool_specified" >&6; }
5966       fi
5967     fi
5968   fi
5969 
5970 
5971 
5972   if test "x$CUT" = x; then
5973     as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
5974   fi
5975 
5976 
5977 
5978 
5979 
5980   # Publish this variable in the help.
5981 
5982 
5983   if test "x$DATE" = x; then
5984     # The variable is not set by user, try to locate tool using the code snippet
5985     for ac_prog in date
5986 do
5987   # Extract the first word of "$ac_prog", so it can be a program name with args.
5988 set dummy $ac_prog; ac_word=$2
5989 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5990 $as_echo_n "checking for $ac_word... " >&6; }
5991 if ${ac_cv_path_DATE+:} false; then :
5992   $as_echo_n "(cached) " >&6
5993 else
5994   case $DATE in
5995   [\\/]* | ?:[\\/]*)
5996   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
5997   ;;
5998   *)
5999   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6000 for as_dir in $PATH
6001 do
6002   IFS=$as_save_IFS
6003   test -z "$as_dir" && as_dir=.
6004     for ac_exec_ext in '' $ac_executable_extensions; do
6005   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6006     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6007     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6008     break 2
6009   fi
6010 done
6011   done
6012 IFS=$as_save_IFS
6013 
6014   ;;
6015 esac
6016 fi
6017 DATE=$ac_cv_path_DATE
6018 if test -n "$DATE"; then
6019   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6020 $as_echo "$DATE" >&6; }
6021 else
6022   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6023 $as_echo "no" >&6; }
6024 fi
6025 
6026 
6027   test -n "$DATE" && break
6028 done
6029 
6030   else
6031     # The variable is set, but is it from the command line or the environment?
6032 
6033     # Try to remove the string !DATE! from our list.
6034     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
6035     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6036       # If it failed, the variable was not from the command line. Ignore it,
6037       # but warn the user (except for BASH, which is always set by the calling BASH).
6038       if test "xDATE" != xBASH; then
6039         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
6040 $as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
6041       fi
6042       # Try to locate tool using the code snippet
6043       for ac_prog in date
6044 do
6045   # Extract the first word of "$ac_prog", so it can be a program name with args.
6046 set dummy $ac_prog; ac_word=$2
6047 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6048 $as_echo_n "checking for $ac_word... " >&6; }
6049 if ${ac_cv_path_DATE+:} false; then :
6050   $as_echo_n "(cached) " >&6
6051 else
6052   case $DATE in
6053   [\\/]* | ?:[\\/]*)
6054   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6055   ;;
6056   *)
6057   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6058 for as_dir in $PATH
6059 do
6060   IFS=$as_save_IFS
6061   test -z "$as_dir" && as_dir=.
6062     for ac_exec_ext in '' $ac_executable_extensions; do
6063   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6064     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6065     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6066     break 2
6067   fi
6068 done
6069   done
6070 IFS=$as_save_IFS
6071 
6072   ;;
6073 esac
6074 fi
6075 DATE=$ac_cv_path_DATE
6076 if test -n "$DATE"; then
6077   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6078 $as_echo "$DATE" >&6; }
6079 else
6080   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6081 $as_echo "no" >&6; }
6082 fi
6083 
6084 
6085   test -n "$DATE" && break
6086 done
6087 
6088     else
6089       # If it succeeded, then it was overridden by the user. We will use it
6090       # for the tool.
6091 
6092       # First remove it from the list of overridden variables, so we can test
6093       # for unknown variables in the end.
6094       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6095 
6096       # Check if the provided tool contains a complete path.
6097       tool_specified="$DATE"
6098       tool_basename="${tool_specified##*/}"
6099       if test "x$tool_basename" = "x$tool_specified"; then
6100         # A command without a complete path is provided, search $PATH.
6101         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
6102 $as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
6103         # Extract the first word of "$tool_basename", so it can be a program name with args.
6104 set dummy $tool_basename; ac_word=$2
6105 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6106 $as_echo_n "checking for $ac_word... " >&6; }
6107 if ${ac_cv_path_DATE+:} false; then :
6108   $as_echo_n "(cached) " >&6
6109 else
6110   case $DATE in
6111   [\\/]* | ?:[\\/]*)
6112   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6113   ;;
6114   *)
6115   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6116 for as_dir in $PATH
6117 do
6118   IFS=$as_save_IFS
6119   test -z "$as_dir" && as_dir=.
6120     for ac_exec_ext in '' $ac_executable_extensions; do
6121   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6122     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6123     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6124     break 2
6125   fi
6126 done
6127   done
6128 IFS=$as_save_IFS
6129 
6130   ;;
6131 esac
6132 fi
6133 DATE=$ac_cv_path_DATE
6134 if test -n "$DATE"; then
6135   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6136 $as_echo "$DATE" >&6; }
6137 else
6138   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6139 $as_echo "no" >&6; }
6140 fi
6141 
6142 
6143         if test "x$DATE" = x; then
6144           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6145         fi
6146       else
6147         # Otherwise we believe it is a complete path. Use it as it is.
6148         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
6149 $as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
6150         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6151 $as_echo_n "checking for DATE... " >&6; }
6152         if test ! -x "$tool_specified"; then
6153           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6154 $as_echo "not found" >&6; }
6155           as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
6156         fi
6157         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6158 $as_echo "$tool_specified" >&6; }
6159       fi
6160     fi
6161   fi
6162 
6163 
6164 
6165   if test "x$DATE" = x; then
6166     as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
6167   fi
6168 
6169 
6170 
6171 
6172 
6173   # Publish this variable in the help.
6174 
6175 
6176   if test "x$DIFF" = x; then
6177     # The variable is not set by user, try to locate tool using the code snippet
6178     for ac_prog in gdiff diff
6179 do
6180   # Extract the first word of "$ac_prog", so it can be a program name with args.
6181 set dummy $ac_prog; ac_word=$2
6182 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6183 $as_echo_n "checking for $ac_word... " >&6; }
6184 if ${ac_cv_path_DIFF+:} false; then :
6185   $as_echo_n "(cached) " >&6
6186 else
6187   case $DIFF in
6188   [\\/]* | ?:[\\/]*)
6189   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6190   ;;
6191   *)
6192   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6193 for as_dir in $PATH
6194 do
6195   IFS=$as_save_IFS
6196   test -z "$as_dir" && as_dir=.
6197     for ac_exec_ext in '' $ac_executable_extensions; do
6198   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6199     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6200     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6201     break 2
6202   fi
6203 done
6204   done
6205 IFS=$as_save_IFS
6206 
6207   ;;
6208 esac
6209 fi
6210 DIFF=$ac_cv_path_DIFF
6211 if test -n "$DIFF"; then
6212   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6213 $as_echo "$DIFF" >&6; }
6214 else
6215   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6216 $as_echo "no" >&6; }
6217 fi
6218 
6219 
6220   test -n "$DIFF" && break
6221 done
6222 
6223   else
6224     # The variable is set, but is it from the command line or the environment?
6225 
6226     # Try to remove the string !DIFF! from our list.
6227     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
6228     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6229       # If it failed, the variable was not from the command line. Ignore it,
6230       # but warn the user (except for BASH, which is always set by the calling BASH).
6231       if test "xDIFF" != xBASH; then
6232         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
6233 $as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
6234       fi
6235       # Try to locate tool using the code snippet
6236       for ac_prog in gdiff diff
6237 do
6238   # Extract the first word of "$ac_prog", so it can be a program name with args.
6239 set dummy $ac_prog; ac_word=$2
6240 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6241 $as_echo_n "checking for $ac_word... " >&6; }
6242 if ${ac_cv_path_DIFF+:} false; then :
6243   $as_echo_n "(cached) " >&6
6244 else
6245   case $DIFF in
6246   [\\/]* | ?:[\\/]*)
6247   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6248   ;;
6249   *)
6250   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6251 for as_dir in $PATH
6252 do
6253   IFS=$as_save_IFS
6254   test -z "$as_dir" && as_dir=.
6255     for ac_exec_ext in '' $ac_executable_extensions; do
6256   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6257     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6258     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6259     break 2
6260   fi
6261 done
6262   done
6263 IFS=$as_save_IFS
6264 
6265   ;;
6266 esac
6267 fi
6268 DIFF=$ac_cv_path_DIFF
6269 if test -n "$DIFF"; then
6270   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6271 $as_echo "$DIFF" >&6; }
6272 else
6273   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6274 $as_echo "no" >&6; }
6275 fi
6276 
6277 
6278   test -n "$DIFF" && break
6279 done
6280 
6281     else
6282       # If it succeeded, then it was overridden by the user. We will use it
6283       # for the tool.
6284 
6285       # First remove it from the list of overridden variables, so we can test
6286       # for unknown variables in the end.
6287       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6288 
6289       # Check if the provided tool contains a complete path.
6290       tool_specified="$DIFF"
6291       tool_basename="${tool_specified##*/}"
6292       if test "x$tool_basename" = "x$tool_specified"; then
6293         # A command without a complete path is provided, search $PATH.
6294         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
6295 $as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
6296         # Extract the first word of "$tool_basename", so it can be a program name with args.
6297 set dummy $tool_basename; ac_word=$2
6298 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6299 $as_echo_n "checking for $ac_word... " >&6; }
6300 if ${ac_cv_path_DIFF+:} false; then :
6301   $as_echo_n "(cached) " >&6
6302 else
6303   case $DIFF in
6304   [\\/]* | ?:[\\/]*)
6305   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6306   ;;
6307   *)
6308   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6309 for as_dir in $PATH
6310 do
6311   IFS=$as_save_IFS
6312   test -z "$as_dir" && as_dir=.
6313     for ac_exec_ext in '' $ac_executable_extensions; do
6314   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6315     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6316     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6317     break 2
6318   fi
6319 done
6320   done
6321 IFS=$as_save_IFS
6322 
6323   ;;
6324 esac
6325 fi
6326 DIFF=$ac_cv_path_DIFF
6327 if test -n "$DIFF"; then
6328   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6329 $as_echo "$DIFF" >&6; }
6330 else
6331   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6332 $as_echo "no" >&6; }
6333 fi
6334 
6335 
6336         if test "x$DIFF" = x; then
6337           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6338         fi
6339       else
6340         # Otherwise we believe it is a complete path. Use it as it is.
6341         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
6342 $as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
6343         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
6344 $as_echo_n "checking for DIFF... " >&6; }
6345         if test ! -x "$tool_specified"; then
6346           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6347 $as_echo "not found" >&6; }
6348           as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
6349         fi
6350         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6351 $as_echo "$tool_specified" >&6; }
6352       fi
6353     fi
6354   fi
6355 
6356 
6357 
6358   if test "x$DIFF" = x; then
6359     as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
6360   fi
6361 
6362 
6363 
6364 
6365 
6366   # Publish this variable in the help.
6367 
6368 
6369   if test "x$DIRNAME" = x; then
6370     # The variable is not set by user, try to locate tool using the code snippet
6371     for ac_prog in dirname
6372 do
6373   # Extract the first word of "$ac_prog", so it can be a program name with args.
6374 set dummy $ac_prog; ac_word=$2
6375 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6376 $as_echo_n "checking for $ac_word... " >&6; }
6377 if ${ac_cv_path_DIRNAME+:} false; then :
6378   $as_echo_n "(cached) " >&6
6379 else
6380   case $DIRNAME in
6381   [\\/]* | ?:[\\/]*)
6382   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6383   ;;
6384   *)
6385   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6386 for as_dir in $PATH
6387 do
6388   IFS=$as_save_IFS
6389   test -z "$as_dir" && as_dir=.
6390     for ac_exec_ext in '' $ac_executable_extensions; do
6391   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6392     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6393     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6394     break 2
6395   fi
6396 done
6397   done
6398 IFS=$as_save_IFS
6399 
6400   ;;
6401 esac
6402 fi
6403 DIRNAME=$ac_cv_path_DIRNAME
6404 if test -n "$DIRNAME"; then
6405   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6406 $as_echo "$DIRNAME" >&6; }
6407 else
6408   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6409 $as_echo "no" >&6; }
6410 fi
6411 
6412 
6413   test -n "$DIRNAME" && break
6414 done
6415 
6416   else
6417     # The variable is set, but is it from the command line or the environment?
6418 
6419     # Try to remove the string !DIRNAME! from our list.
6420     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
6421     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6422       # If it failed, the variable was not from the command line. Ignore it,
6423       # but warn the user (except for BASH, which is always set by the calling BASH).
6424       if test "xDIRNAME" != xBASH; then
6425         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
6426 $as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
6427       fi
6428       # Try to locate tool using the code snippet
6429       for ac_prog in dirname
6430 do
6431   # Extract the first word of "$ac_prog", so it can be a program name with args.
6432 set dummy $ac_prog; ac_word=$2
6433 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6434 $as_echo_n "checking for $ac_word... " >&6; }
6435 if ${ac_cv_path_DIRNAME+:} false; then :
6436   $as_echo_n "(cached) " >&6
6437 else
6438   case $DIRNAME in
6439   [\\/]* | ?:[\\/]*)
6440   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6441   ;;
6442   *)
6443   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6444 for as_dir in $PATH
6445 do
6446   IFS=$as_save_IFS
6447   test -z "$as_dir" && as_dir=.
6448     for ac_exec_ext in '' $ac_executable_extensions; do
6449   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6450     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6451     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6452     break 2
6453   fi
6454 done
6455   done
6456 IFS=$as_save_IFS
6457 
6458   ;;
6459 esac
6460 fi
6461 DIRNAME=$ac_cv_path_DIRNAME
6462 if test -n "$DIRNAME"; then
6463   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6464 $as_echo "$DIRNAME" >&6; }
6465 else
6466   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6467 $as_echo "no" >&6; }
6468 fi
6469 
6470 
6471   test -n "$DIRNAME" && break
6472 done
6473 
6474     else
6475       # If it succeeded, then it was overridden by the user. We will use it
6476       # for the tool.
6477 
6478       # First remove it from the list of overridden variables, so we can test
6479       # for unknown variables in the end.
6480       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6481 
6482       # Check if the provided tool contains a complete path.
6483       tool_specified="$DIRNAME"
6484       tool_basename="${tool_specified##*/}"
6485       if test "x$tool_basename" = "x$tool_specified"; then
6486         # A command without a complete path is provided, search $PATH.
6487         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
6488 $as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
6489         # Extract the first word of "$tool_basename", so it can be a program name with args.
6490 set dummy $tool_basename; ac_word=$2
6491 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6492 $as_echo_n "checking for $ac_word... " >&6; }
6493 if ${ac_cv_path_DIRNAME+:} false; then :
6494   $as_echo_n "(cached) " >&6
6495 else
6496   case $DIRNAME in
6497   [\\/]* | ?:[\\/]*)
6498   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6499   ;;
6500   *)
6501   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6502 for as_dir in $PATH
6503 do
6504   IFS=$as_save_IFS
6505   test -z "$as_dir" && as_dir=.
6506     for ac_exec_ext in '' $ac_executable_extensions; do
6507   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6508     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6509     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6510     break 2
6511   fi
6512 done
6513   done
6514 IFS=$as_save_IFS
6515 
6516   ;;
6517 esac
6518 fi
6519 DIRNAME=$ac_cv_path_DIRNAME
6520 if test -n "$DIRNAME"; then
6521   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6522 $as_echo "$DIRNAME" >&6; }
6523 else
6524   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6525 $as_echo "no" >&6; }
6526 fi
6527 
6528 
6529         if test "x$DIRNAME" = x; then
6530           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6531         fi
6532       else
6533         # Otherwise we believe it is a complete path. Use it as it is.
6534         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
6535 $as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
6536         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
6537 $as_echo_n "checking for DIRNAME... " >&6; }
6538         if test ! -x "$tool_specified"; then
6539           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6540 $as_echo "not found" >&6; }
6541           as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
6542         fi
6543         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6544 $as_echo "$tool_specified" >&6; }
6545       fi
6546     fi
6547   fi
6548 
6549 
6550 
6551   if test "x$DIRNAME" = x; then
6552     as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
6553   fi
6554 
6555 
6556 
6557 
6558 
6559   # Publish this variable in the help.
6560 
6561 
6562   if test "x$ECHO" = x; then
6563     # The variable is not set by user, try to locate tool using the code snippet
6564     for ac_prog in echo
6565 do
6566   # Extract the first word of "$ac_prog", so it can be a program name with args.
6567 set dummy $ac_prog; ac_word=$2
6568 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6569 $as_echo_n "checking for $ac_word... " >&6; }
6570 if ${ac_cv_path_ECHO+:} false; then :
6571   $as_echo_n "(cached) " >&6
6572 else
6573   case $ECHO in
6574   [\\/]* | ?:[\\/]*)
6575   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6576   ;;
6577   *)
6578   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6579 for as_dir in $PATH
6580 do
6581   IFS=$as_save_IFS
6582   test -z "$as_dir" && as_dir=.
6583     for ac_exec_ext in '' $ac_executable_extensions; do
6584   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6585     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6586     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6587     break 2
6588   fi
6589 done
6590   done
6591 IFS=$as_save_IFS
6592 
6593   ;;
6594 esac
6595 fi
6596 ECHO=$ac_cv_path_ECHO
6597 if test -n "$ECHO"; then
6598   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6599 $as_echo "$ECHO" >&6; }
6600 else
6601   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6602 $as_echo "no" >&6; }
6603 fi
6604 
6605 
6606   test -n "$ECHO" && break
6607 done
6608 
6609   else
6610     # The variable is set, but is it from the command line or the environment?
6611 
6612     # Try to remove the string !ECHO! from our list.
6613     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
6614     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6615       # If it failed, the variable was not from the command line. Ignore it,
6616       # but warn the user (except for BASH, which is always set by the calling BASH).
6617       if test "xECHO" != xBASH; then
6618         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
6619 $as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
6620       fi
6621       # Try to locate tool using the code snippet
6622       for ac_prog in echo
6623 do
6624   # Extract the first word of "$ac_prog", so it can be a program name with args.
6625 set dummy $ac_prog; ac_word=$2
6626 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6627 $as_echo_n "checking for $ac_word... " >&6; }
6628 if ${ac_cv_path_ECHO+:} false; then :
6629   $as_echo_n "(cached) " >&6
6630 else
6631   case $ECHO in
6632   [\\/]* | ?:[\\/]*)
6633   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6634   ;;
6635   *)
6636   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6637 for as_dir in $PATH
6638 do
6639   IFS=$as_save_IFS
6640   test -z "$as_dir" && as_dir=.
6641     for ac_exec_ext in '' $ac_executable_extensions; do
6642   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6643     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6644     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6645     break 2
6646   fi
6647 done
6648   done
6649 IFS=$as_save_IFS
6650 
6651   ;;
6652 esac
6653 fi
6654 ECHO=$ac_cv_path_ECHO
6655 if test -n "$ECHO"; then
6656   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6657 $as_echo "$ECHO" >&6; }
6658 else
6659   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6660 $as_echo "no" >&6; }
6661 fi
6662 
6663 
6664   test -n "$ECHO" && break
6665 done
6666 
6667     else
6668       # If it succeeded, then it was overridden by the user. We will use it
6669       # for the tool.
6670 
6671       # First remove it from the list of overridden variables, so we can test
6672       # for unknown variables in the end.
6673       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6674 
6675       # Check if the provided tool contains a complete path.
6676       tool_specified="$ECHO"
6677       tool_basename="${tool_specified##*/}"
6678       if test "x$tool_basename" = "x$tool_specified"; then
6679         # A command without a complete path is provided, search $PATH.
6680         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
6681 $as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
6682         # Extract the first word of "$tool_basename", so it can be a program name with args.
6683 set dummy $tool_basename; ac_word=$2
6684 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6685 $as_echo_n "checking for $ac_word... " >&6; }
6686 if ${ac_cv_path_ECHO+:} false; then :
6687   $as_echo_n "(cached) " >&6
6688 else
6689   case $ECHO in
6690   [\\/]* | ?:[\\/]*)
6691   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6692   ;;
6693   *)
6694   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6695 for as_dir in $PATH
6696 do
6697   IFS=$as_save_IFS
6698   test -z "$as_dir" && as_dir=.
6699     for ac_exec_ext in '' $ac_executable_extensions; do
6700   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6701     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6702     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6703     break 2
6704   fi
6705 done
6706   done
6707 IFS=$as_save_IFS
6708 
6709   ;;
6710 esac
6711 fi
6712 ECHO=$ac_cv_path_ECHO
6713 if test -n "$ECHO"; then
6714   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6715 $as_echo "$ECHO" >&6; }
6716 else
6717   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6718 $as_echo "no" >&6; }
6719 fi
6720 
6721 
6722         if test "x$ECHO" = x; then
6723           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6724         fi
6725       else
6726         # Otherwise we believe it is a complete path. Use it as it is.
6727         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
6728 $as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
6729         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
6730 $as_echo_n "checking for ECHO... " >&6; }
6731         if test ! -x "$tool_specified"; then
6732           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6733 $as_echo "not found" >&6; }
6734           as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
6735         fi
6736         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6737 $as_echo "$tool_specified" >&6; }
6738       fi
6739     fi
6740   fi
6741 
6742 
6743 
6744   if test "x$ECHO" = x; then
6745     as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
6746   fi
6747 
6748 
6749 
6750 
6751 
6752   # Publish this variable in the help.
6753 
6754 
6755   if test "x$EXPR" = x; then
6756     # The variable is not set by user, try to locate tool using the code snippet
6757     for ac_prog in expr
6758 do
6759   # Extract the first word of "$ac_prog", so it can be a program name with args.
6760 set dummy $ac_prog; ac_word=$2
6761 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6762 $as_echo_n "checking for $ac_word... " >&6; }
6763 if ${ac_cv_path_EXPR+:} false; then :
6764   $as_echo_n "(cached) " >&6
6765 else
6766   case $EXPR in
6767   [\\/]* | ?:[\\/]*)
6768   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6769   ;;
6770   *)
6771   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6772 for as_dir in $PATH
6773 do
6774   IFS=$as_save_IFS
6775   test -z "$as_dir" && as_dir=.
6776     for ac_exec_ext in '' $ac_executable_extensions; do
6777   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6778     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6779     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6780     break 2
6781   fi
6782 done
6783   done
6784 IFS=$as_save_IFS
6785 
6786   ;;
6787 esac
6788 fi
6789 EXPR=$ac_cv_path_EXPR
6790 if test -n "$EXPR"; then
6791   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6792 $as_echo "$EXPR" >&6; }
6793 else
6794   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6795 $as_echo "no" >&6; }
6796 fi
6797 
6798 
6799   test -n "$EXPR" && break
6800 done
6801 
6802   else
6803     # The variable is set, but is it from the command line or the environment?
6804 
6805     # Try to remove the string !EXPR! from our list.
6806     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
6807     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6808       # If it failed, the variable was not from the command line. Ignore it,
6809       # but warn the user (except for BASH, which is always set by the calling BASH).
6810       if test "xEXPR" != xBASH; then
6811         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
6812 $as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
6813       fi
6814       # Try to locate tool using the code snippet
6815       for ac_prog in expr
6816 do
6817   # Extract the first word of "$ac_prog", so it can be a program name with args.
6818 set dummy $ac_prog; ac_word=$2
6819 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6820 $as_echo_n "checking for $ac_word... " >&6; }
6821 if ${ac_cv_path_EXPR+:} false; then :
6822   $as_echo_n "(cached) " >&6
6823 else
6824   case $EXPR in
6825   [\\/]* | ?:[\\/]*)
6826   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6827   ;;
6828   *)
6829   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6830 for as_dir in $PATH
6831 do
6832   IFS=$as_save_IFS
6833   test -z "$as_dir" && as_dir=.
6834     for ac_exec_ext in '' $ac_executable_extensions; do
6835   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6836     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6837     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6838     break 2
6839   fi
6840 done
6841   done
6842 IFS=$as_save_IFS
6843 
6844   ;;
6845 esac
6846 fi
6847 EXPR=$ac_cv_path_EXPR
6848 if test -n "$EXPR"; then
6849   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6850 $as_echo "$EXPR" >&6; }
6851 else
6852   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6853 $as_echo "no" >&6; }
6854 fi
6855 
6856 
6857   test -n "$EXPR" && break
6858 done
6859 
6860     else
6861       # If it succeeded, then it was overridden by the user. We will use it
6862       # for the tool.
6863 
6864       # First remove it from the list of overridden variables, so we can test
6865       # for unknown variables in the end.
6866       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6867 
6868       # Check if the provided tool contains a complete path.
6869       tool_specified="$EXPR"
6870       tool_basename="${tool_specified##*/}"
6871       if test "x$tool_basename" = "x$tool_specified"; then
6872         # A command without a complete path is provided, search $PATH.
6873         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
6874 $as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
6875         # Extract the first word of "$tool_basename", so it can be a program name with args.
6876 set dummy $tool_basename; ac_word=$2
6877 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6878 $as_echo_n "checking for $ac_word... " >&6; }
6879 if ${ac_cv_path_EXPR+:} false; then :
6880   $as_echo_n "(cached) " >&6
6881 else
6882   case $EXPR in
6883   [\\/]* | ?:[\\/]*)
6884   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6885   ;;
6886   *)
6887   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6888 for as_dir in $PATH
6889 do
6890   IFS=$as_save_IFS
6891   test -z "$as_dir" && as_dir=.
6892     for ac_exec_ext in '' $ac_executable_extensions; do
6893   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6894     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6895     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6896     break 2
6897   fi
6898 done
6899   done
6900 IFS=$as_save_IFS
6901 
6902   ;;
6903 esac
6904 fi
6905 EXPR=$ac_cv_path_EXPR
6906 if test -n "$EXPR"; then
6907   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6908 $as_echo "$EXPR" >&6; }
6909 else
6910   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6911 $as_echo "no" >&6; }
6912 fi
6913 
6914 
6915         if test "x$EXPR" = x; then
6916           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6917         fi
6918       else
6919         # Otherwise we believe it is a complete path. Use it as it is.
6920         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
6921 $as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
6922         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
6923 $as_echo_n "checking for EXPR... " >&6; }
6924         if test ! -x "$tool_specified"; then
6925           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6926 $as_echo "not found" >&6; }
6927           as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
6928         fi
6929         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6930 $as_echo "$tool_specified" >&6; }
6931       fi
6932     fi
6933   fi
6934 
6935 
6936 
6937   if test "x$EXPR" = x; then
6938     as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
6939   fi
6940 
6941 
6942 
6943 
6944 
6945   # Publish this variable in the help.
6946 
6947 
6948   if test "x$FILE" = x; then
6949     # The variable is not set by user, try to locate tool using the code snippet
6950     for ac_prog in file
6951 do
6952   # Extract the first word of "$ac_prog", so it can be a program name with args.
6953 set dummy $ac_prog; ac_word=$2
6954 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6955 $as_echo_n "checking for $ac_word... " >&6; }
6956 if ${ac_cv_path_FILE+:} false; then :
6957   $as_echo_n "(cached) " >&6
6958 else
6959   case $FILE in
6960   [\\/]* | ?:[\\/]*)
6961   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
6962   ;;
6963   *)
6964   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6965 for as_dir in $PATH
6966 do
6967   IFS=$as_save_IFS
6968   test -z "$as_dir" && as_dir=.
6969     for ac_exec_ext in '' $ac_executable_extensions; do
6970   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6971     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
6972     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6973     break 2
6974   fi
6975 done
6976   done
6977 IFS=$as_save_IFS
6978 
6979   ;;
6980 esac
6981 fi
6982 FILE=$ac_cv_path_FILE
6983 if test -n "$FILE"; then
6984   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
6985 $as_echo "$FILE" >&6; }
6986 else
6987   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6988 $as_echo "no" >&6; }
6989 fi
6990 
6991 
6992   test -n "$FILE" && break
6993 done
6994 
6995   else
6996     # The variable is set, but is it from the command line or the environment?
6997 
6998     # Try to remove the string !FILE! from our list.
6999     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
7000     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7001       # If it failed, the variable was not from the command line. Ignore it,
7002       # but warn the user (except for BASH, which is always set by the calling BASH).
7003       if test "xFILE" != xBASH; then
7004         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
7005 $as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
7006       fi
7007       # Try to locate tool using the code snippet
7008       for ac_prog in file
7009 do
7010   # Extract the first word of "$ac_prog", so it can be a program name with args.
7011 set dummy $ac_prog; ac_word=$2
7012 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7013 $as_echo_n "checking for $ac_word... " >&6; }
7014 if ${ac_cv_path_FILE+:} false; then :
7015   $as_echo_n "(cached) " >&6
7016 else
7017   case $FILE in
7018   [\\/]* | ?:[\\/]*)
7019   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7020   ;;
7021   *)
7022   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7023 for as_dir in $PATH
7024 do
7025   IFS=$as_save_IFS
7026   test -z "$as_dir" && as_dir=.
7027     for ac_exec_ext in '' $ac_executable_extensions; do
7028   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7029     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7030     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7031     break 2
7032   fi
7033 done
7034   done
7035 IFS=$as_save_IFS
7036 
7037   ;;
7038 esac
7039 fi
7040 FILE=$ac_cv_path_FILE
7041 if test -n "$FILE"; then
7042   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7043 $as_echo "$FILE" >&6; }
7044 else
7045   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7046 $as_echo "no" >&6; }
7047 fi
7048 
7049 
7050   test -n "$FILE" && break
7051 done
7052 
7053     else
7054       # If it succeeded, then it was overridden by the user. We will use it
7055       # for the tool.
7056 
7057       # First remove it from the list of overridden variables, so we can test
7058       # for unknown variables in the end.
7059       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7060 
7061       # Check if the provided tool contains a complete path.
7062       tool_specified="$FILE"
7063       tool_basename="${tool_specified##*/}"
7064       if test "x$tool_basename" = "x$tool_specified"; then
7065         # A command without a complete path is provided, search $PATH.
7066         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
7067 $as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
7068         # Extract the first word of "$tool_basename", so it can be a program name with args.
7069 set dummy $tool_basename; ac_word=$2
7070 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7071 $as_echo_n "checking for $ac_word... " >&6; }
7072 if ${ac_cv_path_FILE+:} false; then :
7073   $as_echo_n "(cached) " >&6
7074 else
7075   case $FILE in
7076   [\\/]* | ?:[\\/]*)
7077   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7078   ;;
7079   *)
7080   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7081 for as_dir in $PATH
7082 do
7083   IFS=$as_save_IFS
7084   test -z "$as_dir" && as_dir=.
7085     for ac_exec_ext in '' $ac_executable_extensions; do
7086   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7087     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7088     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7089     break 2
7090   fi
7091 done
7092   done
7093 IFS=$as_save_IFS
7094 
7095   ;;
7096 esac
7097 fi
7098 FILE=$ac_cv_path_FILE
7099 if test -n "$FILE"; then
7100   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7101 $as_echo "$FILE" >&6; }
7102 else
7103   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7104 $as_echo "no" >&6; }
7105 fi
7106 
7107 
7108         if test "x$FILE" = x; then
7109           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7110         fi
7111       else
7112         # Otherwise we believe it is a complete path. Use it as it is.
7113         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
7114 $as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
7115         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7116 $as_echo_n "checking for FILE... " >&6; }
7117         if test ! -x "$tool_specified"; then
7118           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7119 $as_echo "not found" >&6; }
7120           as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
7121         fi
7122         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7123 $as_echo "$tool_specified" >&6; }
7124       fi
7125     fi
7126   fi
7127 
7128 
7129 
7130   if test "x$FILE" = x; then
7131     as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
7132   fi
7133 
7134 
7135 
7136 
7137 
7138   # Publish this variable in the help.
7139 
7140 
7141   if test "x$FIND" = x; then
7142     # The variable is not set by user, try to locate tool using the code snippet
7143     for ac_prog in find
7144 do
7145   # Extract the first word of "$ac_prog", so it can be a program name with args.
7146 set dummy $ac_prog; ac_word=$2
7147 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7148 $as_echo_n "checking for $ac_word... " >&6; }
7149 if ${ac_cv_path_FIND+:} false; then :
7150   $as_echo_n "(cached) " >&6
7151 else
7152   case $FIND in
7153   [\\/]* | ?:[\\/]*)
7154   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7155   ;;
7156   *)
7157   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7158 for as_dir in $PATH
7159 do
7160   IFS=$as_save_IFS
7161   test -z "$as_dir" && as_dir=.
7162     for ac_exec_ext in '' $ac_executable_extensions; do
7163   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7164     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7165     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7166     break 2
7167   fi
7168 done
7169   done
7170 IFS=$as_save_IFS
7171 
7172   ;;
7173 esac
7174 fi
7175 FIND=$ac_cv_path_FIND
7176 if test -n "$FIND"; then
7177   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7178 $as_echo "$FIND" >&6; }
7179 else
7180   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7181 $as_echo "no" >&6; }
7182 fi
7183 
7184 
7185   test -n "$FIND" && break
7186 done
7187 
7188   else
7189     # The variable is set, but is it from the command line or the environment?
7190 
7191     # Try to remove the string !FIND! from our list.
7192     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
7193     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7194       # If it failed, the variable was not from the command line. Ignore it,
7195       # but warn the user (except for BASH, which is always set by the calling BASH).
7196       if test "xFIND" != xBASH; then
7197         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
7198 $as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
7199       fi
7200       # Try to locate tool using the code snippet
7201       for ac_prog in find
7202 do
7203   # Extract the first word of "$ac_prog", so it can be a program name with args.
7204 set dummy $ac_prog; ac_word=$2
7205 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7206 $as_echo_n "checking for $ac_word... " >&6; }
7207 if ${ac_cv_path_FIND+:} false; then :
7208   $as_echo_n "(cached) " >&6
7209 else
7210   case $FIND in
7211   [\\/]* | ?:[\\/]*)
7212   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7213   ;;
7214   *)
7215   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7216 for as_dir in $PATH
7217 do
7218   IFS=$as_save_IFS
7219   test -z "$as_dir" && as_dir=.
7220     for ac_exec_ext in '' $ac_executable_extensions; do
7221   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7222     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7223     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7224     break 2
7225   fi
7226 done
7227   done
7228 IFS=$as_save_IFS
7229 
7230   ;;
7231 esac
7232 fi
7233 FIND=$ac_cv_path_FIND
7234 if test -n "$FIND"; then
7235   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7236 $as_echo "$FIND" >&6; }
7237 else
7238   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7239 $as_echo "no" >&6; }
7240 fi
7241 
7242 
7243   test -n "$FIND" && break
7244 done
7245 
7246     else
7247       # If it succeeded, then it was overridden by the user. We will use it
7248       # for the tool.
7249 
7250       # First remove it from the list of overridden variables, so we can test
7251       # for unknown variables in the end.
7252       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7253 
7254       # Check if the provided tool contains a complete path.
7255       tool_specified="$FIND"
7256       tool_basename="${tool_specified##*/}"
7257       if test "x$tool_basename" = "x$tool_specified"; then
7258         # A command without a complete path is provided, search $PATH.
7259         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
7260 $as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
7261         # Extract the first word of "$tool_basename", so it can be a program name with args.
7262 set dummy $tool_basename; ac_word=$2
7263 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7264 $as_echo_n "checking for $ac_word... " >&6; }
7265 if ${ac_cv_path_FIND+:} false; then :
7266   $as_echo_n "(cached) " >&6
7267 else
7268   case $FIND in
7269   [\\/]* | ?:[\\/]*)
7270   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7271   ;;
7272   *)
7273   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7274 for as_dir in $PATH
7275 do
7276   IFS=$as_save_IFS
7277   test -z "$as_dir" && as_dir=.
7278     for ac_exec_ext in '' $ac_executable_extensions; do
7279   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7280     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7281     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7282     break 2
7283   fi
7284 done
7285   done
7286 IFS=$as_save_IFS
7287 
7288   ;;
7289 esac
7290 fi
7291 FIND=$ac_cv_path_FIND
7292 if test -n "$FIND"; then
7293   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7294 $as_echo "$FIND" >&6; }
7295 else
7296   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7297 $as_echo "no" >&6; }
7298 fi
7299 
7300 
7301         if test "x$FIND" = x; then
7302           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7303         fi
7304       else
7305         # Otherwise we believe it is a complete path. Use it as it is.
7306         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
7307 $as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
7308         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
7309 $as_echo_n "checking for FIND... " >&6; }
7310         if test ! -x "$tool_specified"; then
7311           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7312 $as_echo "not found" >&6; }
7313           as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
7314         fi
7315         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7316 $as_echo "$tool_specified" >&6; }
7317       fi
7318     fi
7319   fi
7320 
7321 
7322 
7323   if test "x$FIND" = x; then
7324     as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
7325   fi
7326 
7327 
7328 
7329 
7330 
7331   # Publish this variable in the help.
7332 
7333 
7334   if test "x$HEAD" = x; then
7335     # The variable is not set by user, try to locate tool using the code snippet
7336     for ac_prog in head
7337 do
7338   # Extract the first word of "$ac_prog", so it can be a program name with args.
7339 set dummy $ac_prog; ac_word=$2
7340 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7341 $as_echo_n "checking for $ac_word... " >&6; }
7342 if ${ac_cv_path_HEAD+:} false; then :
7343   $as_echo_n "(cached) " >&6
7344 else
7345   case $HEAD in
7346   [\\/]* | ?:[\\/]*)
7347   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7348   ;;
7349   *)
7350   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7351 for as_dir in $PATH
7352 do
7353   IFS=$as_save_IFS
7354   test -z "$as_dir" && as_dir=.
7355     for ac_exec_ext in '' $ac_executable_extensions; do
7356   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7357     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7358     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7359     break 2
7360   fi
7361 done
7362   done
7363 IFS=$as_save_IFS
7364 
7365   ;;
7366 esac
7367 fi
7368 HEAD=$ac_cv_path_HEAD
7369 if test -n "$HEAD"; then
7370   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7371 $as_echo "$HEAD" >&6; }
7372 else
7373   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7374 $as_echo "no" >&6; }
7375 fi
7376 
7377 
7378   test -n "$HEAD" && break
7379 done
7380 
7381   else
7382     # The variable is set, but is it from the command line or the environment?
7383 
7384     # Try to remove the string !HEAD! from our list.
7385     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
7386     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7387       # If it failed, the variable was not from the command line. Ignore it,
7388       # but warn the user (except for BASH, which is always set by the calling BASH).
7389       if test "xHEAD" != xBASH; then
7390         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
7391 $as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
7392       fi
7393       # Try to locate tool using the code snippet
7394       for ac_prog in head
7395 do
7396   # Extract the first word of "$ac_prog", so it can be a program name with args.
7397 set dummy $ac_prog; ac_word=$2
7398 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7399 $as_echo_n "checking for $ac_word... " >&6; }
7400 if ${ac_cv_path_HEAD+:} false; then :
7401   $as_echo_n "(cached) " >&6
7402 else
7403   case $HEAD in
7404   [\\/]* | ?:[\\/]*)
7405   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7406   ;;
7407   *)
7408   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7409 for as_dir in $PATH
7410 do
7411   IFS=$as_save_IFS
7412   test -z "$as_dir" && as_dir=.
7413     for ac_exec_ext in '' $ac_executable_extensions; do
7414   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7415     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7416     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7417     break 2
7418   fi
7419 done
7420   done
7421 IFS=$as_save_IFS
7422 
7423   ;;
7424 esac
7425 fi
7426 HEAD=$ac_cv_path_HEAD
7427 if test -n "$HEAD"; then
7428   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7429 $as_echo "$HEAD" >&6; }
7430 else
7431   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7432 $as_echo "no" >&6; }
7433 fi
7434 
7435 
7436   test -n "$HEAD" && break
7437 done
7438 
7439     else
7440       # If it succeeded, then it was overridden by the user. We will use it
7441       # for the tool.
7442 
7443       # First remove it from the list of overridden variables, so we can test
7444       # for unknown variables in the end.
7445       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7446 
7447       # Check if the provided tool contains a complete path.
7448       tool_specified="$HEAD"
7449       tool_basename="${tool_specified##*/}"
7450       if test "x$tool_basename" = "x$tool_specified"; then
7451         # A command without a complete path is provided, search $PATH.
7452         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
7453 $as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
7454         # Extract the first word of "$tool_basename", so it can be a program name with args.
7455 set dummy $tool_basename; ac_word=$2
7456 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7457 $as_echo_n "checking for $ac_word... " >&6; }
7458 if ${ac_cv_path_HEAD+:} false; then :
7459   $as_echo_n "(cached) " >&6
7460 else
7461   case $HEAD in
7462   [\\/]* | ?:[\\/]*)
7463   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7464   ;;
7465   *)
7466   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7467 for as_dir in $PATH
7468 do
7469   IFS=$as_save_IFS
7470   test -z "$as_dir" && as_dir=.
7471     for ac_exec_ext in '' $ac_executable_extensions; do
7472   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7473     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7474     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7475     break 2
7476   fi
7477 done
7478   done
7479 IFS=$as_save_IFS
7480 
7481   ;;
7482 esac
7483 fi
7484 HEAD=$ac_cv_path_HEAD
7485 if test -n "$HEAD"; then
7486   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7487 $as_echo "$HEAD" >&6; }
7488 else
7489   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7490 $as_echo "no" >&6; }
7491 fi
7492 
7493 
7494         if test "x$HEAD" = x; then
7495           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7496         fi
7497       else
7498         # Otherwise we believe it is a complete path. Use it as it is.
7499         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
7500 $as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
7501         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
7502 $as_echo_n "checking for HEAD... " >&6; }
7503         if test ! -x "$tool_specified"; then
7504           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7505 $as_echo "not found" >&6; }
7506           as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
7507         fi
7508         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7509 $as_echo "$tool_specified" >&6; }
7510       fi
7511     fi
7512   fi
7513 
7514 
7515 
7516   if test "x$HEAD" = x; then
7517     as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
7518   fi
7519 
7520 
7521 
7522 
7523 
7524   # Publish this variable in the help.
7525 
7526 
7527   if test "x$LN" = x; then
7528     # The variable is not set by user, try to locate tool using the code snippet
7529     for ac_prog in ln
7530 do
7531   # Extract the first word of "$ac_prog", so it can be a program name with args.
7532 set dummy $ac_prog; ac_word=$2
7533 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7534 $as_echo_n "checking for $ac_word... " >&6; }
7535 if ${ac_cv_path_LN+:} false; then :
7536   $as_echo_n "(cached) " >&6
7537 else
7538   case $LN in
7539   [\\/]* | ?:[\\/]*)
7540   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7541   ;;
7542   *)
7543   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7544 for as_dir in $PATH
7545 do
7546   IFS=$as_save_IFS
7547   test -z "$as_dir" && as_dir=.
7548     for ac_exec_ext in '' $ac_executable_extensions; do
7549   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7550     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7551     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7552     break 2
7553   fi
7554 done
7555   done
7556 IFS=$as_save_IFS
7557 
7558   ;;
7559 esac
7560 fi
7561 LN=$ac_cv_path_LN
7562 if test -n "$LN"; then
7563   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7564 $as_echo "$LN" >&6; }
7565 else
7566   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7567 $as_echo "no" >&6; }
7568 fi
7569 
7570 
7571   test -n "$LN" && break
7572 done
7573 
7574   else
7575     # The variable is set, but is it from the command line or the environment?
7576 
7577     # Try to remove the string !LN! from our list.
7578     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
7579     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7580       # If it failed, the variable was not from the command line. Ignore it,
7581       # but warn the user (except for BASH, which is always set by the calling BASH).
7582       if test "xLN" != xBASH; then
7583         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
7584 $as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
7585       fi
7586       # Try to locate tool using the code snippet
7587       for ac_prog in ln
7588 do
7589   # Extract the first word of "$ac_prog", so it can be a program name with args.
7590 set dummy $ac_prog; ac_word=$2
7591 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7592 $as_echo_n "checking for $ac_word... " >&6; }
7593 if ${ac_cv_path_LN+:} false; then :
7594   $as_echo_n "(cached) " >&6
7595 else
7596   case $LN in
7597   [\\/]* | ?:[\\/]*)
7598   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7599   ;;
7600   *)
7601   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7602 for as_dir in $PATH
7603 do
7604   IFS=$as_save_IFS
7605   test -z "$as_dir" && as_dir=.
7606     for ac_exec_ext in '' $ac_executable_extensions; do
7607   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7608     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7609     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7610     break 2
7611   fi
7612 done
7613   done
7614 IFS=$as_save_IFS
7615 
7616   ;;
7617 esac
7618 fi
7619 LN=$ac_cv_path_LN
7620 if test -n "$LN"; then
7621   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7622 $as_echo "$LN" >&6; }
7623 else
7624   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7625 $as_echo "no" >&6; }
7626 fi
7627 
7628 
7629   test -n "$LN" && break
7630 done
7631 
7632     else
7633       # If it succeeded, then it was overridden by the user. We will use it
7634       # for the tool.
7635 
7636       # First remove it from the list of overridden variables, so we can test
7637       # for unknown variables in the end.
7638       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7639 
7640       # Check if the provided tool contains a complete path.
7641       tool_specified="$LN"
7642       tool_basename="${tool_specified##*/}"
7643       if test "x$tool_basename" = "x$tool_specified"; then
7644         # A command without a complete path is provided, search $PATH.
7645         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
7646 $as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
7647         # Extract the first word of "$tool_basename", so it can be a program name with args.
7648 set dummy $tool_basename; ac_word=$2
7649 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7650 $as_echo_n "checking for $ac_word... " >&6; }
7651 if ${ac_cv_path_LN+:} false; then :
7652   $as_echo_n "(cached) " >&6
7653 else
7654   case $LN in
7655   [\\/]* | ?:[\\/]*)
7656   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7657   ;;
7658   *)
7659   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7660 for as_dir in $PATH
7661 do
7662   IFS=$as_save_IFS
7663   test -z "$as_dir" && as_dir=.
7664     for ac_exec_ext in '' $ac_executable_extensions; do
7665   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7666     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7667     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7668     break 2
7669   fi
7670 done
7671   done
7672 IFS=$as_save_IFS
7673 
7674   ;;
7675 esac
7676 fi
7677 LN=$ac_cv_path_LN
7678 if test -n "$LN"; then
7679   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7680 $as_echo "$LN" >&6; }
7681 else
7682   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7683 $as_echo "no" >&6; }
7684 fi
7685 
7686 
7687         if test "x$LN" = x; then
7688           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7689         fi
7690       else
7691         # Otherwise we believe it is a complete path. Use it as it is.
7692         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
7693 $as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
7694         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
7695 $as_echo_n "checking for LN... " >&6; }
7696         if test ! -x "$tool_specified"; then
7697           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7698 $as_echo "not found" >&6; }
7699           as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
7700         fi
7701         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7702 $as_echo "$tool_specified" >&6; }
7703       fi
7704     fi
7705   fi
7706 
7707 
7708 
7709   if test "x$LN" = x; then
7710     as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
7711   fi
7712 
7713 
7714 
7715 
7716 
7717   # Publish this variable in the help.
7718 
7719 
7720   if test "x$LS" = x; then
7721     # The variable is not set by user, try to locate tool using the code snippet
7722     for ac_prog in ls
7723 do
7724   # Extract the first word of "$ac_prog", so it can be a program name with args.
7725 set dummy $ac_prog; ac_word=$2
7726 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7727 $as_echo_n "checking for $ac_word... " >&6; }
7728 if ${ac_cv_path_LS+:} false; then :
7729   $as_echo_n "(cached) " >&6
7730 else
7731   case $LS in
7732   [\\/]* | ?:[\\/]*)
7733   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7734   ;;
7735   *)
7736   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7737 for as_dir in $PATH
7738 do
7739   IFS=$as_save_IFS
7740   test -z "$as_dir" && as_dir=.
7741     for ac_exec_ext in '' $ac_executable_extensions; do
7742   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7743     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7744     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7745     break 2
7746   fi
7747 done
7748   done
7749 IFS=$as_save_IFS
7750 
7751   ;;
7752 esac
7753 fi
7754 LS=$ac_cv_path_LS
7755 if test -n "$LS"; then
7756   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7757 $as_echo "$LS" >&6; }
7758 else
7759   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7760 $as_echo "no" >&6; }
7761 fi
7762 
7763 
7764   test -n "$LS" && break
7765 done
7766 
7767   else
7768     # The variable is set, but is it from the command line or the environment?
7769 
7770     # Try to remove the string !LS! from our list.
7771     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
7772     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7773       # If it failed, the variable was not from the command line. Ignore it,
7774       # but warn the user (except for BASH, which is always set by the calling BASH).
7775       if test "xLS" != xBASH; then
7776         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
7777 $as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
7778       fi
7779       # Try to locate tool using the code snippet
7780       for ac_prog in ls
7781 do
7782   # Extract the first word of "$ac_prog", so it can be a program name with args.
7783 set dummy $ac_prog; ac_word=$2
7784 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7785 $as_echo_n "checking for $ac_word... " >&6; }
7786 if ${ac_cv_path_LS+:} false; then :
7787   $as_echo_n "(cached) " >&6
7788 else
7789   case $LS in
7790   [\\/]* | ?:[\\/]*)
7791   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7792   ;;
7793   *)
7794   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7795 for as_dir in $PATH
7796 do
7797   IFS=$as_save_IFS
7798   test -z "$as_dir" && as_dir=.
7799     for ac_exec_ext in '' $ac_executable_extensions; do
7800   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7801     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7802     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7803     break 2
7804   fi
7805 done
7806   done
7807 IFS=$as_save_IFS
7808 
7809   ;;
7810 esac
7811 fi
7812 LS=$ac_cv_path_LS
7813 if test -n "$LS"; then
7814   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7815 $as_echo "$LS" >&6; }
7816 else
7817   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7818 $as_echo "no" >&6; }
7819 fi
7820 
7821 
7822   test -n "$LS" && break
7823 done
7824 
7825     else
7826       # If it succeeded, then it was overridden by the user. We will use it
7827       # for the tool.
7828 
7829       # First remove it from the list of overridden variables, so we can test
7830       # for unknown variables in the end.
7831       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7832 
7833       # Check if the provided tool contains a complete path.
7834       tool_specified="$LS"
7835       tool_basename="${tool_specified##*/}"
7836       if test "x$tool_basename" = "x$tool_specified"; then
7837         # A command without a complete path is provided, search $PATH.
7838         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
7839 $as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
7840         # Extract the first word of "$tool_basename", so it can be a program name with args.
7841 set dummy $tool_basename; ac_word=$2
7842 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7843 $as_echo_n "checking for $ac_word... " >&6; }
7844 if ${ac_cv_path_LS+:} false; then :
7845   $as_echo_n "(cached) " >&6
7846 else
7847   case $LS in
7848   [\\/]* | ?:[\\/]*)
7849   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7850   ;;
7851   *)
7852   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7853 for as_dir in $PATH
7854 do
7855   IFS=$as_save_IFS
7856   test -z "$as_dir" && as_dir=.
7857     for ac_exec_ext in '' $ac_executable_extensions; do
7858   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7859     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7860     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7861     break 2
7862   fi
7863 done
7864   done
7865 IFS=$as_save_IFS
7866 
7867   ;;
7868 esac
7869 fi
7870 LS=$ac_cv_path_LS
7871 if test -n "$LS"; then
7872   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7873 $as_echo "$LS" >&6; }
7874 else
7875   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7876 $as_echo "no" >&6; }
7877 fi
7878 
7879 
7880         if test "x$LS" = x; then
7881           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7882         fi
7883       else
7884         # Otherwise we believe it is a complete path. Use it as it is.
7885         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
7886 $as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
7887         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
7888 $as_echo_n "checking for LS... " >&6; }
7889         if test ! -x "$tool_specified"; then
7890           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7891 $as_echo "not found" >&6; }
7892           as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
7893         fi
7894         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7895 $as_echo "$tool_specified" >&6; }
7896       fi
7897     fi
7898   fi
7899 
7900 
7901 
7902   if test "x$LS" = x; then
7903     as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
7904   fi
7905 
7906 
7907 
7908 
7909 
7910   # Publish this variable in the help.
7911 
7912 
7913   if test "x$MKDIR" = x; then
7914     # The variable is not set by user, try to locate tool using the code snippet
7915     for ac_prog in mkdir
7916 do
7917   # Extract the first word of "$ac_prog", so it can be a program name with args.
7918 set dummy $ac_prog; ac_word=$2
7919 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7920 $as_echo_n "checking for $ac_word... " >&6; }
7921 if ${ac_cv_path_MKDIR+:} false; then :
7922   $as_echo_n "(cached) " >&6
7923 else
7924   case $MKDIR in
7925   [\\/]* | ?:[\\/]*)
7926   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7927   ;;
7928   *)
7929   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7930 for as_dir in $PATH
7931 do
7932   IFS=$as_save_IFS
7933   test -z "$as_dir" && as_dir=.
7934     for ac_exec_ext in '' $ac_executable_extensions; do
7935   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7936     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7937     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7938     break 2
7939   fi
7940 done
7941   done
7942 IFS=$as_save_IFS
7943 
7944   ;;
7945 esac
7946 fi
7947 MKDIR=$ac_cv_path_MKDIR
7948 if test -n "$MKDIR"; then
7949   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
7950 $as_echo "$MKDIR" >&6; }
7951 else
7952   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7953 $as_echo "no" >&6; }
7954 fi
7955 
7956 
7957   test -n "$MKDIR" && break
7958 done
7959 
7960   else
7961     # The variable is set, but is it from the command line or the environment?
7962 
7963     # Try to remove the string !MKDIR! from our list.
7964     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
7965     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7966       # If it failed, the variable was not from the command line. Ignore it,
7967       # but warn the user (except for BASH, which is always set by the calling BASH).
7968       if test "xMKDIR" != xBASH; then
7969         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
7970 $as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
7971       fi
7972       # Try to locate tool using the code snippet
7973       for ac_prog in mkdir
7974 do
7975   # Extract the first word of "$ac_prog", so it can be a program name with args.
7976 set dummy $ac_prog; ac_word=$2
7977 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7978 $as_echo_n "checking for $ac_word... " >&6; }
7979 if ${ac_cv_path_MKDIR+:} false; then :
7980   $as_echo_n "(cached) " >&6
7981 else
7982   case $MKDIR in
7983   [\\/]* | ?:[\\/]*)
7984   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7985   ;;
7986   *)
7987   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7988 for as_dir in $PATH
7989 do
7990   IFS=$as_save_IFS
7991   test -z "$as_dir" && as_dir=.
7992     for ac_exec_ext in '' $ac_executable_extensions; do
7993   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7994     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7995     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7996     break 2
7997   fi
7998 done
7999   done
8000 IFS=$as_save_IFS
8001 
8002   ;;
8003 esac
8004 fi
8005 MKDIR=$ac_cv_path_MKDIR
8006 if test -n "$MKDIR"; then
8007   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8008 $as_echo "$MKDIR" >&6; }
8009 else
8010   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8011 $as_echo "no" >&6; }
8012 fi
8013 
8014 
8015   test -n "$MKDIR" && break
8016 done
8017 
8018     else
8019       # If it succeeded, then it was overridden by the user. We will use it
8020       # for the tool.
8021 
8022       # First remove it from the list of overridden variables, so we can test
8023       # for unknown variables in the end.
8024       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8025 
8026       # Check if the provided tool contains a complete path.
8027       tool_specified="$MKDIR"
8028       tool_basename="${tool_specified##*/}"
8029       if test "x$tool_basename" = "x$tool_specified"; then
8030         # A command without a complete path is provided, search $PATH.
8031         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
8032 $as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
8033         # Extract the first word of "$tool_basename", so it can be a program name with args.
8034 set dummy $tool_basename; ac_word=$2
8035 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8036 $as_echo_n "checking for $ac_word... " >&6; }
8037 if ${ac_cv_path_MKDIR+:} false; then :
8038   $as_echo_n "(cached) " >&6
8039 else
8040   case $MKDIR in
8041   [\\/]* | ?:[\\/]*)
8042   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8043   ;;
8044   *)
8045   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8046 for as_dir in $PATH
8047 do
8048   IFS=$as_save_IFS
8049   test -z "$as_dir" && as_dir=.
8050     for ac_exec_ext in '' $ac_executable_extensions; do
8051   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8052     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8053     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8054     break 2
8055   fi
8056 done
8057   done
8058 IFS=$as_save_IFS
8059 
8060   ;;
8061 esac
8062 fi
8063 MKDIR=$ac_cv_path_MKDIR
8064 if test -n "$MKDIR"; then
8065   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8066 $as_echo "$MKDIR" >&6; }
8067 else
8068   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8069 $as_echo "no" >&6; }
8070 fi
8071 
8072 
8073         if test "x$MKDIR" = x; then
8074           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8075         fi
8076       else
8077         # Otherwise we believe it is a complete path. Use it as it is.
8078         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
8079 $as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
8080         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
8081 $as_echo_n "checking for MKDIR... " >&6; }
8082         if test ! -x "$tool_specified"; then
8083           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8084 $as_echo "not found" >&6; }
8085           as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
8086         fi
8087         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8088 $as_echo "$tool_specified" >&6; }
8089       fi
8090     fi
8091   fi
8092 
8093 
8094 
8095   if test "x$MKDIR" = x; then
8096     as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
8097   fi
8098 
8099 
8100 
8101 
8102 
8103   # Publish this variable in the help.
8104 
8105 
8106   if test "x$MKTEMP" = x; then
8107     # The variable is not set by user, try to locate tool using the code snippet
8108     for ac_prog in mktemp
8109 do
8110   # Extract the first word of "$ac_prog", so it can be a program name with args.
8111 set dummy $ac_prog; ac_word=$2
8112 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8113 $as_echo_n "checking for $ac_word... " >&6; }
8114 if ${ac_cv_path_MKTEMP+:} false; then :
8115   $as_echo_n "(cached) " >&6
8116 else
8117   case $MKTEMP in
8118   [\\/]* | ?:[\\/]*)
8119   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8120   ;;
8121   *)
8122   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8123 for as_dir in $PATH
8124 do
8125   IFS=$as_save_IFS
8126   test -z "$as_dir" && as_dir=.
8127     for ac_exec_ext in '' $ac_executable_extensions; do
8128   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8129     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8130     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8131     break 2
8132   fi
8133 done
8134   done
8135 IFS=$as_save_IFS
8136 
8137   ;;
8138 esac
8139 fi
8140 MKTEMP=$ac_cv_path_MKTEMP
8141 if test -n "$MKTEMP"; then
8142   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8143 $as_echo "$MKTEMP" >&6; }
8144 else
8145   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8146 $as_echo "no" >&6; }
8147 fi
8148 
8149 
8150   test -n "$MKTEMP" && break
8151 done
8152 
8153   else
8154     # The variable is set, but is it from the command line or the environment?
8155 
8156     # Try to remove the string !MKTEMP! from our list.
8157     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
8158     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8159       # If it failed, the variable was not from the command line. Ignore it,
8160       # but warn the user (except for BASH, which is always set by the calling BASH).
8161       if test "xMKTEMP" != xBASH; then
8162         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
8163 $as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
8164       fi
8165       # Try to locate tool using the code snippet
8166       for ac_prog in mktemp
8167 do
8168   # Extract the first word of "$ac_prog", so it can be a program name with args.
8169 set dummy $ac_prog; ac_word=$2
8170 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8171 $as_echo_n "checking for $ac_word... " >&6; }
8172 if ${ac_cv_path_MKTEMP+:} false; then :
8173   $as_echo_n "(cached) " >&6
8174 else
8175   case $MKTEMP in
8176   [\\/]* | ?:[\\/]*)
8177   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8178   ;;
8179   *)
8180   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8181 for as_dir in $PATH
8182 do
8183   IFS=$as_save_IFS
8184   test -z "$as_dir" && as_dir=.
8185     for ac_exec_ext in '' $ac_executable_extensions; do
8186   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8187     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8188     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8189     break 2
8190   fi
8191 done
8192   done
8193 IFS=$as_save_IFS
8194 
8195   ;;
8196 esac
8197 fi
8198 MKTEMP=$ac_cv_path_MKTEMP
8199 if test -n "$MKTEMP"; then
8200   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8201 $as_echo "$MKTEMP" >&6; }
8202 else
8203   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8204 $as_echo "no" >&6; }
8205 fi
8206 
8207 
8208   test -n "$MKTEMP" && break
8209 done
8210 
8211     else
8212       # If it succeeded, then it was overridden by the user. We will use it
8213       # for the tool.
8214 
8215       # First remove it from the list of overridden variables, so we can test
8216       # for unknown variables in the end.
8217       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8218 
8219       # Check if the provided tool contains a complete path.
8220       tool_specified="$MKTEMP"
8221       tool_basename="${tool_specified##*/}"
8222       if test "x$tool_basename" = "x$tool_specified"; then
8223         # A command without a complete path is provided, search $PATH.
8224         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
8225 $as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
8226         # Extract the first word of "$tool_basename", so it can be a program name with args.
8227 set dummy $tool_basename; ac_word=$2
8228 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8229 $as_echo_n "checking for $ac_word... " >&6; }
8230 if ${ac_cv_path_MKTEMP+:} false; then :
8231   $as_echo_n "(cached) " >&6
8232 else
8233   case $MKTEMP in
8234   [\\/]* | ?:[\\/]*)
8235   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8236   ;;
8237   *)
8238   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8239 for as_dir in $PATH
8240 do
8241   IFS=$as_save_IFS
8242   test -z "$as_dir" && as_dir=.
8243     for ac_exec_ext in '' $ac_executable_extensions; do
8244   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8245     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8246     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8247     break 2
8248   fi
8249 done
8250   done
8251 IFS=$as_save_IFS
8252 
8253   ;;
8254 esac
8255 fi
8256 MKTEMP=$ac_cv_path_MKTEMP
8257 if test -n "$MKTEMP"; then
8258   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8259 $as_echo "$MKTEMP" >&6; }
8260 else
8261   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8262 $as_echo "no" >&6; }
8263 fi
8264 
8265 
8266         if test "x$MKTEMP" = x; then
8267           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8268         fi
8269       else
8270         # Otherwise we believe it is a complete path. Use it as it is.
8271         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
8272 $as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
8273         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
8274 $as_echo_n "checking for MKTEMP... " >&6; }
8275         if test ! -x "$tool_specified"; then
8276           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8277 $as_echo "not found" >&6; }
8278           as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
8279         fi
8280         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8281 $as_echo "$tool_specified" >&6; }
8282       fi
8283     fi
8284   fi
8285 
8286 
8287 
8288   if test "x$MKTEMP" = x; then
8289     as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
8290   fi
8291 
8292 
8293 
8294 
8295 
8296   # Publish this variable in the help.
8297 
8298 
8299   if test "x$MV" = x; then
8300     # The variable is not set by user, try to locate tool using the code snippet
8301     for ac_prog in mv
8302 do
8303   # Extract the first word of "$ac_prog", so it can be a program name with args.
8304 set dummy $ac_prog; ac_word=$2
8305 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8306 $as_echo_n "checking for $ac_word... " >&6; }
8307 if ${ac_cv_path_MV+:} false; then :
8308   $as_echo_n "(cached) " >&6
8309 else
8310   case $MV in
8311   [\\/]* | ?:[\\/]*)
8312   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8313   ;;
8314   *)
8315   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8316 for as_dir in $PATH
8317 do
8318   IFS=$as_save_IFS
8319   test -z "$as_dir" && as_dir=.
8320     for ac_exec_ext in '' $ac_executable_extensions; do
8321   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8322     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8323     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8324     break 2
8325   fi
8326 done
8327   done
8328 IFS=$as_save_IFS
8329 
8330   ;;
8331 esac
8332 fi
8333 MV=$ac_cv_path_MV
8334 if test -n "$MV"; then
8335   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8336 $as_echo "$MV" >&6; }
8337 else
8338   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8339 $as_echo "no" >&6; }
8340 fi
8341 
8342 
8343   test -n "$MV" && break
8344 done
8345 
8346   else
8347     # The variable is set, but is it from the command line or the environment?
8348 
8349     # Try to remove the string !MV! from our list.
8350     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
8351     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8352       # If it failed, the variable was not from the command line. Ignore it,
8353       # but warn the user (except for BASH, which is always set by the calling BASH).
8354       if test "xMV" != xBASH; then
8355         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
8356 $as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
8357       fi
8358       # Try to locate tool using the code snippet
8359       for ac_prog in mv
8360 do
8361   # Extract the first word of "$ac_prog", so it can be a program name with args.
8362 set dummy $ac_prog; ac_word=$2
8363 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8364 $as_echo_n "checking for $ac_word... " >&6; }
8365 if ${ac_cv_path_MV+:} false; then :
8366   $as_echo_n "(cached) " >&6
8367 else
8368   case $MV in
8369   [\\/]* | ?:[\\/]*)
8370   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8371   ;;
8372   *)
8373   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8374 for as_dir in $PATH
8375 do
8376   IFS=$as_save_IFS
8377   test -z "$as_dir" && as_dir=.
8378     for ac_exec_ext in '' $ac_executable_extensions; do
8379   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8380     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8381     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8382     break 2
8383   fi
8384 done
8385   done
8386 IFS=$as_save_IFS
8387 
8388   ;;
8389 esac
8390 fi
8391 MV=$ac_cv_path_MV
8392 if test -n "$MV"; then
8393   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8394 $as_echo "$MV" >&6; }
8395 else
8396   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8397 $as_echo "no" >&6; }
8398 fi
8399 
8400 
8401   test -n "$MV" && break
8402 done
8403 
8404     else
8405       # If it succeeded, then it was overridden by the user. We will use it
8406       # for the tool.
8407 
8408       # First remove it from the list of overridden variables, so we can test
8409       # for unknown variables in the end.
8410       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8411 
8412       # Check if the provided tool contains a complete path.
8413       tool_specified="$MV"
8414       tool_basename="${tool_specified##*/}"
8415       if test "x$tool_basename" = "x$tool_specified"; then
8416         # A command without a complete path is provided, search $PATH.
8417         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
8418 $as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
8419         # Extract the first word of "$tool_basename", so it can be a program name with args.
8420 set dummy $tool_basename; ac_word=$2
8421 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8422 $as_echo_n "checking for $ac_word... " >&6; }
8423 if ${ac_cv_path_MV+:} false; then :
8424   $as_echo_n "(cached) " >&6
8425 else
8426   case $MV in
8427   [\\/]* | ?:[\\/]*)
8428   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8429   ;;
8430   *)
8431   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8432 for as_dir in $PATH
8433 do
8434   IFS=$as_save_IFS
8435   test -z "$as_dir" && as_dir=.
8436     for ac_exec_ext in '' $ac_executable_extensions; do
8437   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8438     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8439     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8440     break 2
8441   fi
8442 done
8443   done
8444 IFS=$as_save_IFS
8445 
8446   ;;
8447 esac
8448 fi
8449 MV=$ac_cv_path_MV
8450 if test -n "$MV"; then
8451   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8452 $as_echo "$MV" >&6; }
8453 else
8454   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8455 $as_echo "no" >&6; }
8456 fi
8457 
8458 
8459         if test "x$MV" = x; then
8460           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8461         fi
8462       else
8463         # Otherwise we believe it is a complete path. Use it as it is.
8464         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
8465 $as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
8466         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
8467 $as_echo_n "checking for MV... " >&6; }
8468         if test ! -x "$tool_specified"; then
8469           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8470 $as_echo "not found" >&6; }
8471           as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
8472         fi
8473         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8474 $as_echo "$tool_specified" >&6; }
8475       fi
8476     fi
8477   fi
8478 
8479 
8480 
8481   if test "x$MV" = x; then
8482     as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
8483   fi
8484 
8485 
8486 
8487 
8488 
8489   # Publish this variable in the help.
8490 
8491 
8492   if test "x$NAWK" = x; then
8493     # The variable is not set by user, try to locate tool using the code snippet
8494     for ac_prog in nawk gawk awk
8495 do
8496   # Extract the first word of "$ac_prog", so it can be a program name with args.
8497 set dummy $ac_prog; ac_word=$2
8498 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8499 $as_echo_n "checking for $ac_word... " >&6; }
8500 if ${ac_cv_path_NAWK+:} false; then :
8501   $as_echo_n "(cached) " >&6
8502 else
8503   case $NAWK in
8504   [\\/]* | ?:[\\/]*)
8505   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8506   ;;
8507   *)
8508   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8509 for as_dir in $PATH
8510 do
8511   IFS=$as_save_IFS
8512   test -z "$as_dir" && as_dir=.
8513     for ac_exec_ext in '' $ac_executable_extensions; do
8514   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8515     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8516     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8517     break 2
8518   fi
8519 done
8520   done
8521 IFS=$as_save_IFS
8522 
8523   ;;
8524 esac
8525 fi
8526 NAWK=$ac_cv_path_NAWK
8527 if test -n "$NAWK"; then
8528   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8529 $as_echo "$NAWK" >&6; }
8530 else
8531   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8532 $as_echo "no" >&6; }
8533 fi
8534 
8535 
8536   test -n "$NAWK" && break
8537 done
8538 
8539   else
8540     # The variable is set, but is it from the command line or the environment?
8541 
8542     # Try to remove the string !NAWK! from our list.
8543     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
8544     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8545       # If it failed, the variable was not from the command line. Ignore it,
8546       # but warn the user (except for BASH, which is always set by the calling BASH).
8547       if test "xNAWK" != xBASH; then
8548         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
8549 $as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
8550       fi
8551       # Try to locate tool using the code snippet
8552       for ac_prog in nawk gawk awk
8553 do
8554   # Extract the first word of "$ac_prog", so it can be a program name with args.
8555 set dummy $ac_prog; ac_word=$2
8556 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8557 $as_echo_n "checking for $ac_word... " >&6; }
8558 if ${ac_cv_path_NAWK+:} false; then :
8559   $as_echo_n "(cached) " >&6
8560 else
8561   case $NAWK in
8562   [\\/]* | ?:[\\/]*)
8563   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8564   ;;
8565   *)
8566   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8567 for as_dir in $PATH
8568 do
8569   IFS=$as_save_IFS
8570   test -z "$as_dir" && as_dir=.
8571     for ac_exec_ext in '' $ac_executable_extensions; do
8572   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8573     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8574     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8575     break 2
8576   fi
8577 done
8578   done
8579 IFS=$as_save_IFS
8580 
8581   ;;
8582 esac
8583 fi
8584 NAWK=$ac_cv_path_NAWK
8585 if test -n "$NAWK"; then
8586   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8587 $as_echo "$NAWK" >&6; }
8588 else
8589   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8590 $as_echo "no" >&6; }
8591 fi
8592 
8593 
8594   test -n "$NAWK" && break
8595 done
8596 
8597     else
8598       # If it succeeded, then it was overridden by the user. We will use it
8599       # for the tool.
8600 
8601       # First remove it from the list of overridden variables, so we can test
8602       # for unknown variables in the end.
8603       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8604 
8605       # Check if the provided tool contains a complete path.
8606       tool_specified="$NAWK"
8607       tool_basename="${tool_specified##*/}"
8608       if test "x$tool_basename" = "x$tool_specified"; then
8609         # A command without a complete path is provided, search $PATH.
8610         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
8611 $as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
8612         # Extract the first word of "$tool_basename", so it can be a program name with args.
8613 set dummy $tool_basename; ac_word=$2
8614 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8615 $as_echo_n "checking for $ac_word... " >&6; }
8616 if ${ac_cv_path_NAWK+:} false; then :
8617   $as_echo_n "(cached) " >&6
8618 else
8619   case $NAWK in
8620   [\\/]* | ?:[\\/]*)
8621   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8622   ;;
8623   *)
8624   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8625 for as_dir in $PATH
8626 do
8627   IFS=$as_save_IFS
8628   test -z "$as_dir" && as_dir=.
8629     for ac_exec_ext in '' $ac_executable_extensions; do
8630   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8631     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8632     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8633     break 2
8634   fi
8635 done
8636   done
8637 IFS=$as_save_IFS
8638 
8639   ;;
8640 esac
8641 fi
8642 NAWK=$ac_cv_path_NAWK
8643 if test -n "$NAWK"; then
8644   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8645 $as_echo "$NAWK" >&6; }
8646 else
8647   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8648 $as_echo "no" >&6; }
8649 fi
8650 
8651 
8652         if test "x$NAWK" = x; then
8653           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8654         fi
8655       else
8656         # Otherwise we believe it is a complete path. Use it as it is.
8657         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
8658 $as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
8659         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
8660 $as_echo_n "checking for NAWK... " >&6; }
8661         if test ! -x "$tool_specified"; then
8662           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8663 $as_echo "not found" >&6; }
8664           as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
8665         fi
8666         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8667 $as_echo "$tool_specified" >&6; }
8668       fi
8669     fi
8670   fi
8671 
8672 
8673 
8674   if test "x$NAWK" = x; then
8675     as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
8676   fi
8677 
8678 
8679 
8680 
8681 
8682   # Publish this variable in the help.
8683 
8684 
8685   if test "x$PRINTF" = x; then
8686     # The variable is not set by user, try to locate tool using the code snippet
8687     for ac_prog in printf
8688 do
8689   # Extract the first word of "$ac_prog", so it can be a program name with args.
8690 set dummy $ac_prog; ac_word=$2
8691 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8692 $as_echo_n "checking for $ac_word... " >&6; }
8693 if ${ac_cv_path_PRINTF+:} false; then :
8694   $as_echo_n "(cached) " >&6
8695 else
8696   case $PRINTF in
8697   [\\/]* | ?:[\\/]*)
8698   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8699   ;;
8700   *)
8701   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8702 for as_dir in $PATH
8703 do
8704   IFS=$as_save_IFS
8705   test -z "$as_dir" && as_dir=.
8706     for ac_exec_ext in '' $ac_executable_extensions; do
8707   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8708     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8709     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8710     break 2
8711   fi
8712 done
8713   done
8714 IFS=$as_save_IFS
8715 
8716   ;;
8717 esac
8718 fi
8719 PRINTF=$ac_cv_path_PRINTF
8720 if test -n "$PRINTF"; then
8721   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8722 $as_echo "$PRINTF" >&6; }
8723 else
8724   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8725 $as_echo "no" >&6; }
8726 fi
8727 
8728 
8729   test -n "$PRINTF" && break
8730 done
8731 
8732   else
8733     # The variable is set, but is it from the command line or the environment?
8734 
8735     # Try to remove the string !PRINTF! from our list.
8736     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
8737     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8738       # If it failed, the variable was not from the command line. Ignore it,
8739       # but warn the user (except for BASH, which is always set by the calling BASH).
8740       if test "xPRINTF" != xBASH; then
8741         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
8742 $as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
8743       fi
8744       # Try to locate tool using the code snippet
8745       for ac_prog in printf
8746 do
8747   # Extract the first word of "$ac_prog", so it can be a program name with args.
8748 set dummy $ac_prog; ac_word=$2
8749 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8750 $as_echo_n "checking for $ac_word... " >&6; }
8751 if ${ac_cv_path_PRINTF+:} false; then :
8752   $as_echo_n "(cached) " >&6
8753 else
8754   case $PRINTF in
8755   [\\/]* | ?:[\\/]*)
8756   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8757   ;;
8758   *)
8759   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8760 for as_dir in $PATH
8761 do
8762   IFS=$as_save_IFS
8763   test -z "$as_dir" && as_dir=.
8764     for ac_exec_ext in '' $ac_executable_extensions; do
8765   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8766     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8767     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8768     break 2
8769   fi
8770 done
8771   done
8772 IFS=$as_save_IFS
8773 
8774   ;;
8775 esac
8776 fi
8777 PRINTF=$ac_cv_path_PRINTF
8778 if test -n "$PRINTF"; then
8779   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8780 $as_echo "$PRINTF" >&6; }
8781 else
8782   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8783 $as_echo "no" >&6; }
8784 fi
8785 
8786 
8787   test -n "$PRINTF" && break
8788 done
8789 
8790     else
8791       # If it succeeded, then it was overridden by the user. We will use it
8792       # for the tool.
8793 
8794       # First remove it from the list of overridden variables, so we can test
8795       # for unknown variables in the end.
8796       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8797 
8798       # Check if the provided tool contains a complete path.
8799       tool_specified="$PRINTF"
8800       tool_basename="${tool_specified##*/}"
8801       if test "x$tool_basename" = "x$tool_specified"; then
8802         # A command without a complete path is provided, search $PATH.
8803         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
8804 $as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
8805         # Extract the first word of "$tool_basename", so it can be a program name with args.
8806 set dummy $tool_basename; ac_word=$2
8807 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8808 $as_echo_n "checking for $ac_word... " >&6; }
8809 if ${ac_cv_path_PRINTF+:} false; then :
8810   $as_echo_n "(cached) " >&6
8811 else
8812   case $PRINTF in
8813   [\\/]* | ?:[\\/]*)
8814   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8815   ;;
8816   *)
8817   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8818 for as_dir in $PATH
8819 do
8820   IFS=$as_save_IFS
8821   test -z "$as_dir" && as_dir=.
8822     for ac_exec_ext in '' $ac_executable_extensions; do
8823   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8824     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8825     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8826     break 2
8827   fi
8828 done
8829   done
8830 IFS=$as_save_IFS
8831 
8832   ;;
8833 esac
8834 fi
8835 PRINTF=$ac_cv_path_PRINTF
8836 if test -n "$PRINTF"; then
8837   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8838 $as_echo "$PRINTF" >&6; }
8839 else
8840   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8841 $as_echo "no" >&6; }
8842 fi
8843 
8844 
8845         if test "x$PRINTF" = x; then
8846           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8847         fi
8848       else
8849         # Otherwise we believe it is a complete path. Use it as it is.
8850         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
8851 $as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
8852         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
8853 $as_echo_n "checking for PRINTF... " >&6; }
8854         if test ! -x "$tool_specified"; then
8855           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8856 $as_echo "not found" >&6; }
8857           as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
8858         fi
8859         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8860 $as_echo "$tool_specified" >&6; }
8861       fi
8862     fi
8863   fi
8864 
8865 
8866 
8867   if test "x$PRINTF" = x; then
8868     as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
8869   fi
8870 
8871 
8872 
8873 
8874 
8875   # Publish this variable in the help.
8876 
8877 
8878   if test "x$RM" = x; then
8879     # The variable is not set by user, try to locate tool using the code snippet
8880     for ac_prog in rm
8881 do
8882   # Extract the first word of "$ac_prog", so it can be a program name with args.
8883 set dummy $ac_prog; ac_word=$2
8884 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8885 $as_echo_n "checking for $ac_word... " >&6; }
8886 if ${ac_cv_path_RM+:} false; then :
8887   $as_echo_n "(cached) " >&6
8888 else
8889   case $RM in
8890   [\\/]* | ?:[\\/]*)
8891   ac_cv_path_RM="$RM" # Let the user override the test with a path.
8892   ;;
8893   *)
8894   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8895 for as_dir in $PATH
8896 do
8897   IFS=$as_save_IFS
8898   test -z "$as_dir" && as_dir=.
8899     for ac_exec_ext in '' $ac_executable_extensions; do
8900   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8901     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8902     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8903     break 2
8904   fi
8905 done
8906   done
8907 IFS=$as_save_IFS
8908 
8909   ;;
8910 esac
8911 fi
8912 RM=$ac_cv_path_RM
8913 if test -n "$RM"; then
8914   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8915 $as_echo "$RM" >&6; }
8916 else
8917   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8918 $as_echo "no" >&6; }
8919 fi
8920 
8921 
8922   test -n "$RM" && break
8923 done
8924 
8925   else
8926     # The variable is set, but is it from the command line or the environment?
8927 
8928     # Try to remove the string !RM! from our list.
8929     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
8930     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8931       # If it failed, the variable was not from the command line. Ignore it,
8932       # but warn the user (except for BASH, which is always set by the calling BASH).
8933       if test "xRM" != xBASH; then
8934         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
8935 $as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
8936       fi
8937       # Try to locate tool using the code snippet
8938       for ac_prog in rm
8939 do
8940   # Extract the first word of "$ac_prog", so it can be a program name with args.
8941 set dummy $ac_prog; ac_word=$2
8942 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8943 $as_echo_n "checking for $ac_word... " >&6; }
8944 if ${ac_cv_path_RM+:} false; then :
8945   $as_echo_n "(cached) " >&6
8946 else
8947   case $RM in
8948   [\\/]* | ?:[\\/]*)
8949   ac_cv_path_RM="$RM" # Let the user override the test with a path.
8950   ;;
8951   *)
8952   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8953 for as_dir in $PATH
8954 do
8955   IFS=$as_save_IFS
8956   test -z "$as_dir" && as_dir=.
8957     for ac_exec_ext in '' $ac_executable_extensions; do
8958   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8959     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8960     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8961     break 2
8962   fi
8963 done
8964   done
8965 IFS=$as_save_IFS
8966 
8967   ;;
8968 esac
8969 fi
8970 RM=$ac_cv_path_RM
8971 if test -n "$RM"; then
8972   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8973 $as_echo "$RM" >&6; }
8974 else
8975   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8976 $as_echo "no" >&6; }
8977 fi
8978 
8979 
8980   test -n "$RM" && break
8981 done
8982 
8983     else
8984       # If it succeeded, then it was overridden by the user. We will use it
8985       # for the tool.
8986 
8987       # First remove it from the list of overridden variables, so we can test
8988       # for unknown variables in the end.
8989       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8990 
8991       # Check if the provided tool contains a complete path.
8992       tool_specified="$RM"
8993       tool_basename="${tool_specified##*/}"
8994       if test "x$tool_basename" = "x$tool_specified"; then
8995         # A command without a complete path is provided, search $PATH.
8996         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
8997 $as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
8998         # Extract the first word of "$tool_basename", so it can be a program name with args.
8999 set dummy $tool_basename; ac_word=$2
9000 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9001 $as_echo_n "checking for $ac_word... " >&6; }
9002 if ${ac_cv_path_RM+:} false; then :
9003   $as_echo_n "(cached) " >&6
9004 else
9005   case $RM in
9006   [\\/]* | ?:[\\/]*)
9007   ac_cv_path_RM="$RM" # Let the user override the test with a path.
9008   ;;
9009   *)
9010   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9011 for as_dir in $PATH
9012 do
9013   IFS=$as_save_IFS
9014   test -z "$as_dir" && as_dir=.
9015     for ac_exec_ext in '' $ac_executable_extensions; do
9016   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9017     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
9018     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9019     break 2
9020   fi
9021 done
9022   done
9023 IFS=$as_save_IFS
9024 
9025   ;;
9026 esac
9027 fi
9028 RM=$ac_cv_path_RM
9029 if test -n "$RM"; then
9030   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9031 $as_echo "$RM" >&6; }
9032 else
9033   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9034 $as_echo "no" >&6; }
9035 fi
9036 
9037 
9038         if test "x$RM" = x; then
9039           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9040         fi
9041       else
9042         # Otherwise we believe it is a complete path. Use it as it is.
9043         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
9044 $as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
9045         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
9046 $as_echo_n "checking for RM... " >&6; }
9047         if test ! -x "$tool_specified"; then
9048           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9049 $as_echo "not found" >&6; }
9050           as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
9051         fi
9052         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9053 $as_echo "$tool_specified" >&6; }
9054       fi
9055     fi
9056   fi
9057 
9058 
9059 
9060   if test "x$RM" = x; then
9061     as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
9062   fi
9063 
9064 
9065 
9066 
9067 
9068   # Publish this variable in the help.
9069 
9070 
9071   if test "x$SH" = x; then
9072     # The variable is not set by user, try to locate tool using the code snippet
9073     for ac_prog in sh
9074 do
9075   # Extract the first word of "$ac_prog", so it can be a program name with args.
9076 set dummy $ac_prog; ac_word=$2
9077 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9078 $as_echo_n "checking for $ac_word... " >&6; }
9079 if ${ac_cv_path_SH+:} false; then :
9080   $as_echo_n "(cached) " >&6
9081 else
9082   case $SH in
9083   [\\/]* | ?:[\\/]*)
9084   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9085   ;;
9086   *)
9087   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9088 for as_dir in $PATH
9089 do
9090   IFS=$as_save_IFS
9091   test -z "$as_dir" && as_dir=.
9092     for ac_exec_ext in '' $ac_executable_extensions; do
9093   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9094     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9095     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9096     break 2
9097   fi
9098 done
9099   done
9100 IFS=$as_save_IFS
9101 
9102   ;;
9103 esac
9104 fi
9105 SH=$ac_cv_path_SH
9106 if test -n "$SH"; then
9107   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9108 $as_echo "$SH" >&6; }
9109 else
9110   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9111 $as_echo "no" >&6; }
9112 fi
9113 
9114 
9115   test -n "$SH" && break
9116 done
9117 
9118   else
9119     # The variable is set, but is it from the command line or the environment?
9120 
9121     # Try to remove the string !SH! from our list.
9122     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
9123     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9124       # If it failed, the variable was not from the command line. Ignore it,
9125       # but warn the user (except for BASH, which is always set by the calling BASH).
9126       if test "xSH" != xBASH; then
9127         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
9128 $as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
9129       fi
9130       # Try to locate tool using the code snippet
9131       for ac_prog in sh
9132 do
9133   # Extract the first word of "$ac_prog", so it can be a program name with args.
9134 set dummy $ac_prog; ac_word=$2
9135 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9136 $as_echo_n "checking for $ac_word... " >&6; }
9137 if ${ac_cv_path_SH+:} false; then :
9138   $as_echo_n "(cached) " >&6
9139 else
9140   case $SH in
9141   [\\/]* | ?:[\\/]*)
9142   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9143   ;;
9144   *)
9145   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9146 for as_dir in $PATH
9147 do
9148   IFS=$as_save_IFS
9149   test -z "$as_dir" && as_dir=.
9150     for ac_exec_ext in '' $ac_executable_extensions; do
9151   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9152     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9153     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9154     break 2
9155   fi
9156 done
9157   done
9158 IFS=$as_save_IFS
9159 
9160   ;;
9161 esac
9162 fi
9163 SH=$ac_cv_path_SH
9164 if test -n "$SH"; then
9165   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9166 $as_echo "$SH" >&6; }
9167 else
9168   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9169 $as_echo "no" >&6; }
9170 fi
9171 
9172 
9173   test -n "$SH" && break
9174 done
9175 
9176     else
9177       # If it succeeded, then it was overridden by the user. We will use it
9178       # for the tool.
9179 
9180       # First remove it from the list of overridden variables, so we can test
9181       # for unknown variables in the end.
9182       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9183 
9184       # Check if the provided tool contains a complete path.
9185       tool_specified="$SH"
9186       tool_basename="${tool_specified##*/}"
9187       if test "x$tool_basename" = "x$tool_specified"; then
9188         # A command without a complete path is provided, search $PATH.
9189         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
9190 $as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
9191         # Extract the first word of "$tool_basename", so it can be a program name with args.
9192 set dummy $tool_basename; ac_word=$2
9193 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9194 $as_echo_n "checking for $ac_word... " >&6; }
9195 if ${ac_cv_path_SH+:} false; then :
9196   $as_echo_n "(cached) " >&6
9197 else
9198   case $SH in
9199   [\\/]* | ?:[\\/]*)
9200   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9201   ;;
9202   *)
9203   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9204 for as_dir in $PATH
9205 do
9206   IFS=$as_save_IFS
9207   test -z "$as_dir" && as_dir=.
9208     for ac_exec_ext in '' $ac_executable_extensions; do
9209   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9210     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9211     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9212     break 2
9213   fi
9214 done
9215   done
9216 IFS=$as_save_IFS
9217 
9218   ;;
9219 esac
9220 fi
9221 SH=$ac_cv_path_SH
9222 if test -n "$SH"; then
9223   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9224 $as_echo "$SH" >&6; }
9225 else
9226   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9227 $as_echo "no" >&6; }
9228 fi
9229 
9230 
9231         if test "x$SH" = x; then
9232           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9233         fi
9234       else
9235         # Otherwise we believe it is a complete path. Use it as it is.
9236         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
9237 $as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
9238         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
9239 $as_echo_n "checking for SH... " >&6; }
9240         if test ! -x "$tool_specified"; then
9241           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9242 $as_echo "not found" >&6; }
9243           as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
9244         fi
9245         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9246 $as_echo "$tool_specified" >&6; }
9247       fi
9248     fi
9249   fi
9250 
9251 
9252 
9253   if test "x$SH" = x; then
9254     as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
9255   fi
9256 
9257 
9258 
9259 
9260 
9261   # Publish this variable in the help.
9262 
9263 
9264   if test "x$SORT" = x; then
9265     # The variable is not set by user, try to locate tool using the code snippet
9266     for ac_prog in sort
9267 do
9268   # Extract the first word of "$ac_prog", so it can be a program name with args.
9269 set dummy $ac_prog; ac_word=$2
9270 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9271 $as_echo_n "checking for $ac_word... " >&6; }
9272 if ${ac_cv_path_SORT+:} false; then :
9273   $as_echo_n "(cached) " >&6
9274 else
9275   case $SORT in
9276   [\\/]* | ?:[\\/]*)
9277   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9278   ;;
9279   *)
9280   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9281 for as_dir in $PATH
9282 do
9283   IFS=$as_save_IFS
9284   test -z "$as_dir" && as_dir=.
9285     for ac_exec_ext in '' $ac_executable_extensions; do
9286   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9287     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9288     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9289     break 2
9290   fi
9291 done
9292   done
9293 IFS=$as_save_IFS
9294 
9295   ;;
9296 esac
9297 fi
9298 SORT=$ac_cv_path_SORT
9299 if test -n "$SORT"; then
9300   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9301 $as_echo "$SORT" >&6; }
9302 else
9303   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9304 $as_echo "no" >&6; }
9305 fi
9306 
9307 
9308   test -n "$SORT" && break
9309 done
9310 
9311   else
9312     # The variable is set, but is it from the command line or the environment?
9313 
9314     # Try to remove the string !SORT! from our list.
9315     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
9316     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9317       # If it failed, the variable was not from the command line. Ignore it,
9318       # but warn the user (except for BASH, which is always set by the calling BASH).
9319       if test "xSORT" != xBASH; then
9320         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
9321 $as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
9322       fi
9323       # Try to locate tool using the code snippet
9324       for ac_prog in sort
9325 do
9326   # Extract the first word of "$ac_prog", so it can be a program name with args.
9327 set dummy $ac_prog; ac_word=$2
9328 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9329 $as_echo_n "checking for $ac_word... " >&6; }
9330 if ${ac_cv_path_SORT+:} false; then :
9331   $as_echo_n "(cached) " >&6
9332 else
9333   case $SORT in
9334   [\\/]* | ?:[\\/]*)
9335   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9336   ;;
9337   *)
9338   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9339 for as_dir in $PATH
9340 do
9341   IFS=$as_save_IFS
9342   test -z "$as_dir" && as_dir=.
9343     for ac_exec_ext in '' $ac_executable_extensions; do
9344   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9345     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9346     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9347     break 2
9348   fi
9349 done
9350   done
9351 IFS=$as_save_IFS
9352 
9353   ;;
9354 esac
9355 fi
9356 SORT=$ac_cv_path_SORT
9357 if test -n "$SORT"; then
9358   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9359 $as_echo "$SORT" >&6; }
9360 else
9361   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9362 $as_echo "no" >&6; }
9363 fi
9364 
9365 
9366   test -n "$SORT" && break
9367 done
9368 
9369     else
9370       # If it succeeded, then it was overridden by the user. We will use it
9371       # for the tool.
9372 
9373       # First remove it from the list of overridden variables, so we can test
9374       # for unknown variables in the end.
9375       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9376 
9377       # Check if the provided tool contains a complete path.
9378       tool_specified="$SORT"
9379       tool_basename="${tool_specified##*/}"
9380       if test "x$tool_basename" = "x$tool_specified"; then
9381         # A command without a complete path is provided, search $PATH.
9382         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
9383 $as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
9384         # Extract the first word of "$tool_basename", so it can be a program name with args.
9385 set dummy $tool_basename; ac_word=$2
9386 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9387 $as_echo_n "checking for $ac_word... " >&6; }
9388 if ${ac_cv_path_SORT+:} false; then :
9389   $as_echo_n "(cached) " >&6
9390 else
9391   case $SORT in
9392   [\\/]* | ?:[\\/]*)
9393   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9394   ;;
9395   *)
9396   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9397 for as_dir in $PATH
9398 do
9399   IFS=$as_save_IFS
9400   test -z "$as_dir" && as_dir=.
9401     for ac_exec_ext in '' $ac_executable_extensions; do
9402   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9403     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9404     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9405     break 2
9406   fi
9407 done
9408   done
9409 IFS=$as_save_IFS
9410 
9411   ;;
9412 esac
9413 fi
9414 SORT=$ac_cv_path_SORT
9415 if test -n "$SORT"; then
9416   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9417 $as_echo "$SORT" >&6; }
9418 else
9419   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9420 $as_echo "no" >&6; }
9421 fi
9422 
9423 
9424         if test "x$SORT" = x; then
9425           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9426         fi
9427       else
9428         # Otherwise we believe it is a complete path. Use it as it is.
9429         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
9430 $as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
9431         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
9432 $as_echo_n "checking for SORT... " >&6; }
9433         if test ! -x "$tool_specified"; then
9434           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9435 $as_echo "not found" >&6; }
9436           as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
9437         fi
9438         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9439 $as_echo "$tool_specified" >&6; }
9440       fi
9441     fi
9442   fi
9443 
9444 
9445 
9446   if test "x$SORT" = x; then
9447     as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
9448   fi
9449 
9450 
9451 
9452 
9453 
9454   # Publish this variable in the help.
9455 
9456 
9457   if test "x$TAIL" = x; then
9458     # The variable is not set by user, try to locate tool using the code snippet
9459     for ac_prog in tail
9460 do
9461   # Extract the first word of "$ac_prog", so it can be a program name with args.
9462 set dummy $ac_prog; ac_word=$2
9463 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9464 $as_echo_n "checking for $ac_word... " >&6; }
9465 if ${ac_cv_path_TAIL+:} false; then :
9466   $as_echo_n "(cached) " >&6
9467 else
9468   case $TAIL in
9469   [\\/]* | ?:[\\/]*)
9470   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9471   ;;
9472   *)
9473   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9474 for as_dir in $PATH
9475 do
9476   IFS=$as_save_IFS
9477   test -z "$as_dir" && as_dir=.
9478     for ac_exec_ext in '' $ac_executable_extensions; do
9479   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9480     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9481     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9482     break 2
9483   fi
9484 done
9485   done
9486 IFS=$as_save_IFS
9487 
9488   ;;
9489 esac
9490 fi
9491 TAIL=$ac_cv_path_TAIL
9492 if test -n "$TAIL"; then
9493   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9494 $as_echo "$TAIL" >&6; }
9495 else
9496   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9497 $as_echo "no" >&6; }
9498 fi
9499 
9500 
9501   test -n "$TAIL" && break
9502 done
9503 
9504   else
9505     # The variable is set, but is it from the command line or the environment?
9506 
9507     # Try to remove the string !TAIL! from our list.
9508     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
9509     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9510       # If it failed, the variable was not from the command line. Ignore it,
9511       # but warn the user (except for BASH, which is always set by the calling BASH).
9512       if test "xTAIL" != xBASH; then
9513         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
9514 $as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
9515       fi
9516       # Try to locate tool using the code snippet
9517       for ac_prog in tail
9518 do
9519   # Extract the first word of "$ac_prog", so it can be a program name with args.
9520 set dummy $ac_prog; ac_word=$2
9521 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9522 $as_echo_n "checking for $ac_word... " >&6; }
9523 if ${ac_cv_path_TAIL+:} false; then :
9524   $as_echo_n "(cached) " >&6
9525 else
9526   case $TAIL in
9527   [\\/]* | ?:[\\/]*)
9528   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9529   ;;
9530   *)
9531   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9532 for as_dir in $PATH
9533 do
9534   IFS=$as_save_IFS
9535   test -z "$as_dir" && as_dir=.
9536     for ac_exec_ext in '' $ac_executable_extensions; do
9537   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9538     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9539     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9540     break 2
9541   fi
9542 done
9543   done
9544 IFS=$as_save_IFS
9545 
9546   ;;
9547 esac
9548 fi
9549 TAIL=$ac_cv_path_TAIL
9550 if test -n "$TAIL"; then
9551   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9552 $as_echo "$TAIL" >&6; }
9553 else
9554   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9555 $as_echo "no" >&6; }
9556 fi
9557 
9558 
9559   test -n "$TAIL" && break
9560 done
9561 
9562     else
9563       # If it succeeded, then it was overridden by the user. We will use it
9564       # for the tool.
9565 
9566       # First remove it from the list of overridden variables, so we can test
9567       # for unknown variables in the end.
9568       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9569 
9570       # Check if the provided tool contains a complete path.
9571       tool_specified="$TAIL"
9572       tool_basename="${tool_specified##*/}"
9573       if test "x$tool_basename" = "x$tool_specified"; then
9574         # A command without a complete path is provided, search $PATH.
9575         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
9576 $as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
9577         # Extract the first word of "$tool_basename", so it can be a program name with args.
9578 set dummy $tool_basename; ac_word=$2
9579 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9580 $as_echo_n "checking for $ac_word... " >&6; }
9581 if ${ac_cv_path_TAIL+:} false; then :
9582   $as_echo_n "(cached) " >&6
9583 else
9584   case $TAIL in
9585   [\\/]* | ?:[\\/]*)
9586   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9587   ;;
9588   *)
9589   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9590 for as_dir in $PATH
9591 do
9592   IFS=$as_save_IFS
9593   test -z "$as_dir" && as_dir=.
9594     for ac_exec_ext in '' $ac_executable_extensions; do
9595   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9596     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9597     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9598     break 2
9599   fi
9600 done
9601   done
9602 IFS=$as_save_IFS
9603 
9604   ;;
9605 esac
9606 fi
9607 TAIL=$ac_cv_path_TAIL
9608 if test -n "$TAIL"; then
9609   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9610 $as_echo "$TAIL" >&6; }
9611 else
9612   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9613 $as_echo "no" >&6; }
9614 fi
9615 
9616 
9617         if test "x$TAIL" = x; then
9618           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9619         fi
9620       else
9621         # Otherwise we believe it is a complete path. Use it as it is.
9622         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
9623 $as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
9624         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
9625 $as_echo_n "checking for TAIL... " >&6; }
9626         if test ! -x "$tool_specified"; then
9627           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9628 $as_echo "not found" >&6; }
9629           as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
9630         fi
9631         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9632 $as_echo "$tool_specified" >&6; }
9633       fi
9634     fi
9635   fi
9636 
9637 
9638 
9639   if test "x$TAIL" = x; then
9640     as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
9641   fi
9642 
9643 
9644 
9645 
9646 
9647   # Publish this variable in the help.
9648 
9649 
9650   if test "x$TAR" = x; then
9651     # The variable is not set by user, try to locate tool using the code snippet
9652     for ac_prog in tar
9653 do
9654   # Extract the first word of "$ac_prog", so it can be a program name with args.
9655 set dummy $ac_prog; ac_word=$2
9656 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9657 $as_echo_n "checking for $ac_word... " >&6; }
9658 if ${ac_cv_path_TAR+:} false; then :
9659   $as_echo_n "(cached) " >&6
9660 else
9661   case $TAR in
9662   [\\/]* | ?:[\\/]*)
9663   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9664   ;;
9665   *)
9666   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9667 for as_dir in $PATH
9668 do
9669   IFS=$as_save_IFS
9670   test -z "$as_dir" && as_dir=.
9671     for ac_exec_ext in '' $ac_executable_extensions; do
9672   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9673     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9674     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9675     break 2
9676   fi
9677 done
9678   done
9679 IFS=$as_save_IFS
9680 
9681   ;;
9682 esac
9683 fi
9684 TAR=$ac_cv_path_TAR
9685 if test -n "$TAR"; then
9686   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9687 $as_echo "$TAR" >&6; }
9688 else
9689   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9690 $as_echo "no" >&6; }
9691 fi
9692 
9693 
9694   test -n "$TAR" && break
9695 done
9696 
9697   else
9698     # The variable is set, but is it from the command line or the environment?
9699 
9700     # Try to remove the string !TAR! from our list.
9701     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
9702     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9703       # If it failed, the variable was not from the command line. Ignore it,
9704       # but warn the user (except for BASH, which is always set by the calling BASH).
9705       if test "xTAR" != xBASH; then
9706         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
9707 $as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
9708       fi
9709       # Try to locate tool using the code snippet
9710       for ac_prog in tar
9711 do
9712   # Extract the first word of "$ac_prog", so it can be a program name with args.
9713 set dummy $ac_prog; ac_word=$2
9714 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9715 $as_echo_n "checking for $ac_word... " >&6; }
9716 if ${ac_cv_path_TAR+:} false; then :
9717   $as_echo_n "(cached) " >&6
9718 else
9719   case $TAR in
9720   [\\/]* | ?:[\\/]*)
9721   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9722   ;;
9723   *)
9724   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9725 for as_dir in $PATH
9726 do
9727   IFS=$as_save_IFS
9728   test -z "$as_dir" && as_dir=.
9729     for ac_exec_ext in '' $ac_executable_extensions; do
9730   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9731     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9732     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9733     break 2
9734   fi
9735 done
9736   done
9737 IFS=$as_save_IFS
9738 
9739   ;;
9740 esac
9741 fi
9742 TAR=$ac_cv_path_TAR
9743 if test -n "$TAR"; then
9744   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9745 $as_echo "$TAR" >&6; }
9746 else
9747   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9748 $as_echo "no" >&6; }
9749 fi
9750 
9751 
9752   test -n "$TAR" && break
9753 done
9754 
9755     else
9756       # If it succeeded, then it was overridden by the user. We will use it
9757       # for the tool.
9758 
9759       # First remove it from the list of overridden variables, so we can test
9760       # for unknown variables in the end.
9761       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9762 
9763       # Check if the provided tool contains a complete path.
9764       tool_specified="$TAR"
9765       tool_basename="${tool_specified##*/}"
9766       if test "x$tool_basename" = "x$tool_specified"; then
9767         # A command without a complete path is provided, search $PATH.
9768         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
9769 $as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
9770         # Extract the first word of "$tool_basename", so it can be a program name with args.
9771 set dummy $tool_basename; ac_word=$2
9772 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9773 $as_echo_n "checking for $ac_word... " >&6; }
9774 if ${ac_cv_path_TAR+:} false; then :
9775   $as_echo_n "(cached) " >&6
9776 else
9777   case $TAR in
9778   [\\/]* | ?:[\\/]*)
9779   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9780   ;;
9781   *)
9782   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9783 for as_dir in $PATH
9784 do
9785   IFS=$as_save_IFS
9786   test -z "$as_dir" && as_dir=.
9787     for ac_exec_ext in '' $ac_executable_extensions; do
9788   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9789     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9790     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9791     break 2
9792   fi
9793 done
9794   done
9795 IFS=$as_save_IFS
9796 
9797   ;;
9798 esac
9799 fi
9800 TAR=$ac_cv_path_TAR
9801 if test -n "$TAR"; then
9802   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9803 $as_echo "$TAR" >&6; }
9804 else
9805   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9806 $as_echo "no" >&6; }
9807 fi
9808 
9809 
9810         if test "x$TAR" = x; then
9811           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9812         fi
9813       else
9814         # Otherwise we believe it is a complete path. Use it as it is.
9815         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
9816 $as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
9817         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
9818 $as_echo_n "checking for TAR... " >&6; }
9819         if test ! -x "$tool_specified"; then
9820           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9821 $as_echo "not found" >&6; }
9822           as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
9823         fi
9824         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9825 $as_echo "$tool_specified" >&6; }
9826       fi
9827     fi
9828   fi
9829 
9830 
9831 
9832   if test "x$TAR" = x; then
9833     as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
9834   fi
9835 
9836 
9837 
9838 
9839 
9840   # Publish this variable in the help.
9841 
9842 
9843   if test "x$TEE" = x; then
9844     # The variable is not set by user, try to locate tool using the code snippet
9845     for ac_prog in tee
9846 do
9847   # Extract the first word of "$ac_prog", so it can be a program name with args.
9848 set dummy $ac_prog; ac_word=$2
9849 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9850 $as_echo_n "checking for $ac_word... " >&6; }
9851 if ${ac_cv_path_TEE+:} false; then :
9852   $as_echo_n "(cached) " >&6
9853 else
9854   case $TEE in
9855   [\\/]* | ?:[\\/]*)
9856   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9857   ;;
9858   *)
9859   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9860 for as_dir in $PATH
9861 do
9862   IFS=$as_save_IFS
9863   test -z "$as_dir" && as_dir=.
9864     for ac_exec_ext in '' $ac_executable_extensions; do
9865   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9866     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9867     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9868     break 2
9869   fi
9870 done
9871   done
9872 IFS=$as_save_IFS
9873 
9874   ;;
9875 esac
9876 fi
9877 TEE=$ac_cv_path_TEE
9878 if test -n "$TEE"; then
9879   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9880 $as_echo "$TEE" >&6; }
9881 else
9882   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9883 $as_echo "no" >&6; }
9884 fi
9885 
9886 
9887   test -n "$TEE" && break
9888 done
9889 
9890   else
9891     # The variable is set, but is it from the command line or the environment?
9892 
9893     # Try to remove the string !TEE! from our list.
9894     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
9895     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9896       # If it failed, the variable was not from the command line. Ignore it,
9897       # but warn the user (except for BASH, which is always set by the calling BASH).
9898       if test "xTEE" != xBASH; then
9899         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
9900 $as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
9901       fi
9902       # Try to locate tool using the code snippet
9903       for ac_prog in tee
9904 do
9905   # Extract the first word of "$ac_prog", so it can be a program name with args.
9906 set dummy $ac_prog; ac_word=$2
9907 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9908 $as_echo_n "checking for $ac_word... " >&6; }
9909 if ${ac_cv_path_TEE+:} false; then :
9910   $as_echo_n "(cached) " >&6
9911 else
9912   case $TEE in
9913   [\\/]* | ?:[\\/]*)
9914   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9915   ;;
9916   *)
9917   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9918 for as_dir in $PATH
9919 do
9920   IFS=$as_save_IFS
9921   test -z "$as_dir" && as_dir=.
9922     for ac_exec_ext in '' $ac_executable_extensions; do
9923   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9924     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9925     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9926     break 2
9927   fi
9928 done
9929   done
9930 IFS=$as_save_IFS
9931 
9932   ;;
9933 esac
9934 fi
9935 TEE=$ac_cv_path_TEE
9936 if test -n "$TEE"; then
9937   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9938 $as_echo "$TEE" >&6; }
9939 else
9940   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9941 $as_echo "no" >&6; }
9942 fi
9943 
9944 
9945   test -n "$TEE" && break
9946 done
9947 
9948     else
9949       # If it succeeded, then it was overridden by the user. We will use it
9950       # for the tool.
9951 
9952       # First remove it from the list of overridden variables, so we can test
9953       # for unknown variables in the end.
9954       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9955 
9956       # Check if the provided tool contains a complete path.
9957       tool_specified="$TEE"
9958       tool_basename="${tool_specified##*/}"
9959       if test "x$tool_basename" = "x$tool_specified"; then
9960         # A command without a complete path is provided, search $PATH.
9961         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
9962 $as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
9963         # Extract the first word of "$tool_basename", so it can be a program name with args.
9964 set dummy $tool_basename; ac_word=$2
9965 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9966 $as_echo_n "checking for $ac_word... " >&6; }
9967 if ${ac_cv_path_TEE+:} false; then :
9968   $as_echo_n "(cached) " >&6
9969 else
9970   case $TEE in
9971   [\\/]* | ?:[\\/]*)
9972   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9973   ;;
9974   *)
9975   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9976 for as_dir in $PATH
9977 do
9978   IFS=$as_save_IFS
9979   test -z "$as_dir" && as_dir=.
9980     for ac_exec_ext in '' $ac_executable_extensions; do
9981   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9982     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9983     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9984     break 2
9985   fi
9986 done
9987   done
9988 IFS=$as_save_IFS
9989 
9990   ;;
9991 esac
9992 fi
9993 TEE=$ac_cv_path_TEE
9994 if test -n "$TEE"; then
9995   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9996 $as_echo "$TEE" >&6; }
9997 else
9998   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9999 $as_echo "no" >&6; }
10000 fi
10001 
10002 
10003         if test "x$TEE" = x; then
10004           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10005         fi
10006       else
10007         # Otherwise we believe it is a complete path. Use it as it is.
10008         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
10009 $as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
10010         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
10011 $as_echo_n "checking for TEE... " >&6; }
10012         if test ! -x "$tool_specified"; then
10013           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10014 $as_echo "not found" >&6; }
10015           as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
10016         fi
10017         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10018 $as_echo "$tool_specified" >&6; }
10019       fi
10020     fi
10021   fi
10022 
10023 
10024 
10025   if test "x$TEE" = x; then
10026     as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
10027   fi
10028 
10029 
10030 
10031 
10032 
10033   # Publish this variable in the help.
10034 
10035 
10036   if test "x$TOUCH" = x; then
10037     # The variable is not set by user, try to locate tool using the code snippet
10038     for ac_prog in touch
10039 do
10040   # Extract the first word of "$ac_prog", so it can be a program name with args.
10041 set dummy $ac_prog; ac_word=$2
10042 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10043 $as_echo_n "checking for $ac_word... " >&6; }
10044 if ${ac_cv_path_TOUCH+:} false; then :
10045   $as_echo_n "(cached) " >&6
10046 else
10047   case $TOUCH in
10048   [\\/]* | ?:[\\/]*)
10049   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10050   ;;
10051   *)
10052   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10053 for as_dir in $PATH
10054 do
10055   IFS=$as_save_IFS
10056   test -z "$as_dir" && as_dir=.
10057     for ac_exec_ext in '' $ac_executable_extensions; do
10058   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10059     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10060     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10061     break 2
10062   fi
10063 done
10064   done
10065 IFS=$as_save_IFS
10066 
10067   ;;
10068 esac
10069 fi
10070 TOUCH=$ac_cv_path_TOUCH
10071 if test -n "$TOUCH"; then
10072   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10073 $as_echo "$TOUCH" >&6; }
10074 else
10075   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10076 $as_echo "no" >&6; }
10077 fi
10078 
10079 
10080   test -n "$TOUCH" && break
10081 done
10082 
10083   else
10084     # The variable is set, but is it from the command line or the environment?
10085 
10086     # Try to remove the string !TOUCH! from our list.
10087     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
10088     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10089       # If it failed, the variable was not from the command line. Ignore it,
10090       # but warn the user (except for BASH, which is always set by the calling BASH).
10091       if test "xTOUCH" != xBASH; then
10092         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
10093 $as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
10094       fi
10095       # Try to locate tool using the code snippet
10096       for ac_prog in touch
10097 do
10098   # Extract the first word of "$ac_prog", so it can be a program name with args.
10099 set dummy $ac_prog; ac_word=$2
10100 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10101 $as_echo_n "checking for $ac_word... " >&6; }
10102 if ${ac_cv_path_TOUCH+:} false; then :
10103   $as_echo_n "(cached) " >&6
10104 else
10105   case $TOUCH in
10106   [\\/]* | ?:[\\/]*)
10107   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10108   ;;
10109   *)
10110   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10111 for as_dir in $PATH
10112 do
10113   IFS=$as_save_IFS
10114   test -z "$as_dir" && as_dir=.
10115     for ac_exec_ext in '' $ac_executable_extensions; do
10116   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10117     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10118     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10119     break 2
10120   fi
10121 done
10122   done
10123 IFS=$as_save_IFS
10124 
10125   ;;
10126 esac
10127 fi
10128 TOUCH=$ac_cv_path_TOUCH
10129 if test -n "$TOUCH"; then
10130   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10131 $as_echo "$TOUCH" >&6; }
10132 else
10133   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10134 $as_echo "no" >&6; }
10135 fi
10136 
10137 
10138   test -n "$TOUCH" && break
10139 done
10140 
10141     else
10142       # If it succeeded, then it was overridden by the user. We will use it
10143       # for the tool.
10144 
10145       # First remove it from the list of overridden variables, so we can test
10146       # for unknown variables in the end.
10147       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10148 
10149       # Check if the provided tool contains a complete path.
10150       tool_specified="$TOUCH"
10151       tool_basename="${tool_specified##*/}"
10152       if test "x$tool_basename" = "x$tool_specified"; then
10153         # A command without a complete path is provided, search $PATH.
10154         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
10155 $as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
10156         # Extract the first word of "$tool_basename", so it can be a program name with args.
10157 set dummy $tool_basename; ac_word=$2
10158 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10159 $as_echo_n "checking for $ac_word... " >&6; }
10160 if ${ac_cv_path_TOUCH+:} false; then :
10161   $as_echo_n "(cached) " >&6
10162 else
10163   case $TOUCH in
10164   [\\/]* | ?:[\\/]*)
10165   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10166   ;;
10167   *)
10168   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10169 for as_dir in $PATH
10170 do
10171   IFS=$as_save_IFS
10172   test -z "$as_dir" && as_dir=.
10173     for ac_exec_ext in '' $ac_executable_extensions; do
10174   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10175     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10176     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10177     break 2
10178   fi
10179 done
10180   done
10181 IFS=$as_save_IFS
10182 
10183   ;;
10184 esac
10185 fi
10186 TOUCH=$ac_cv_path_TOUCH
10187 if test -n "$TOUCH"; then
10188   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10189 $as_echo "$TOUCH" >&6; }
10190 else
10191   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10192 $as_echo "no" >&6; }
10193 fi
10194 
10195 
10196         if test "x$TOUCH" = x; then
10197           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10198         fi
10199       else
10200         # Otherwise we believe it is a complete path. Use it as it is.
10201         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
10202 $as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
10203         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
10204 $as_echo_n "checking for TOUCH... " >&6; }
10205         if test ! -x "$tool_specified"; then
10206           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10207 $as_echo "not found" >&6; }
10208           as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
10209         fi
10210         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10211 $as_echo "$tool_specified" >&6; }
10212       fi
10213     fi
10214   fi
10215 
10216 
10217 
10218   if test "x$TOUCH" = x; then
10219     as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
10220   fi
10221 
10222 
10223 
10224 
10225 
10226   # Publish this variable in the help.
10227 
10228 
10229   if test "x$TR" = x; then
10230     # The variable is not set by user, try to locate tool using the code snippet
10231     for ac_prog in tr
10232 do
10233   # Extract the first word of "$ac_prog", so it can be a program name with args.
10234 set dummy $ac_prog; ac_word=$2
10235 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10236 $as_echo_n "checking for $ac_word... " >&6; }
10237 if ${ac_cv_path_TR+:} false; then :
10238   $as_echo_n "(cached) " >&6
10239 else
10240   case $TR in
10241   [\\/]* | ?:[\\/]*)
10242   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10243   ;;
10244   *)
10245   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10246 for as_dir in $PATH
10247 do
10248   IFS=$as_save_IFS
10249   test -z "$as_dir" && as_dir=.
10250     for ac_exec_ext in '' $ac_executable_extensions; do
10251   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10252     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10253     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10254     break 2
10255   fi
10256 done
10257   done
10258 IFS=$as_save_IFS
10259 
10260   ;;
10261 esac
10262 fi
10263 TR=$ac_cv_path_TR
10264 if test -n "$TR"; then
10265   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10266 $as_echo "$TR" >&6; }
10267 else
10268   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10269 $as_echo "no" >&6; }
10270 fi
10271 
10272 
10273   test -n "$TR" && break
10274 done
10275 
10276   else
10277     # The variable is set, but is it from the command line or the environment?
10278 
10279     # Try to remove the string !TR! from our list.
10280     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
10281     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10282       # If it failed, the variable was not from the command line. Ignore it,
10283       # but warn the user (except for BASH, which is always set by the calling BASH).
10284       if test "xTR" != xBASH; then
10285         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
10286 $as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
10287       fi
10288       # Try to locate tool using the code snippet
10289       for ac_prog in tr
10290 do
10291   # Extract the first word of "$ac_prog", so it can be a program name with args.
10292 set dummy $ac_prog; ac_word=$2
10293 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10294 $as_echo_n "checking for $ac_word... " >&6; }
10295 if ${ac_cv_path_TR+:} false; then :
10296   $as_echo_n "(cached) " >&6
10297 else
10298   case $TR in
10299   [\\/]* | ?:[\\/]*)
10300   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10301   ;;
10302   *)
10303   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10304 for as_dir in $PATH
10305 do
10306   IFS=$as_save_IFS
10307   test -z "$as_dir" && as_dir=.
10308     for ac_exec_ext in '' $ac_executable_extensions; do
10309   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10310     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10311     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10312     break 2
10313   fi
10314 done
10315   done
10316 IFS=$as_save_IFS
10317 
10318   ;;
10319 esac
10320 fi
10321 TR=$ac_cv_path_TR
10322 if test -n "$TR"; then
10323   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10324 $as_echo "$TR" >&6; }
10325 else
10326   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10327 $as_echo "no" >&6; }
10328 fi
10329 
10330 
10331   test -n "$TR" && break
10332 done
10333 
10334     else
10335       # If it succeeded, then it was overridden by the user. We will use it
10336       # for the tool.
10337 
10338       # First remove it from the list of overridden variables, so we can test
10339       # for unknown variables in the end.
10340       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10341 
10342       # Check if the provided tool contains a complete path.
10343       tool_specified="$TR"
10344       tool_basename="${tool_specified##*/}"
10345       if test "x$tool_basename" = "x$tool_specified"; then
10346         # A command without a complete path is provided, search $PATH.
10347         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
10348 $as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
10349         # Extract the first word of "$tool_basename", so it can be a program name with args.
10350 set dummy $tool_basename; ac_word=$2
10351 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10352 $as_echo_n "checking for $ac_word... " >&6; }
10353 if ${ac_cv_path_TR+:} false; then :
10354   $as_echo_n "(cached) " >&6
10355 else
10356   case $TR in
10357   [\\/]* | ?:[\\/]*)
10358   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10359   ;;
10360   *)
10361   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10362 for as_dir in $PATH
10363 do
10364   IFS=$as_save_IFS
10365   test -z "$as_dir" && as_dir=.
10366     for ac_exec_ext in '' $ac_executable_extensions; do
10367   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10368     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10369     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10370     break 2
10371   fi
10372 done
10373   done
10374 IFS=$as_save_IFS
10375 
10376   ;;
10377 esac
10378 fi
10379 TR=$ac_cv_path_TR
10380 if test -n "$TR"; then
10381   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10382 $as_echo "$TR" >&6; }
10383 else
10384   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10385 $as_echo "no" >&6; }
10386 fi
10387 
10388 
10389         if test "x$TR" = x; then
10390           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10391         fi
10392       else
10393         # Otherwise we believe it is a complete path. Use it as it is.
10394         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
10395 $as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
10396         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
10397 $as_echo_n "checking for TR... " >&6; }
10398         if test ! -x "$tool_specified"; then
10399           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10400 $as_echo "not found" >&6; }
10401           as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
10402         fi
10403         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10404 $as_echo "$tool_specified" >&6; }
10405       fi
10406     fi
10407   fi
10408 
10409 
10410 
10411   if test "x$TR" = x; then
10412     as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
10413   fi
10414 
10415 
10416 
10417 
10418 
10419   # Publish this variable in the help.
10420 
10421 
10422   if test "x$UNAME" = x; then
10423     # The variable is not set by user, try to locate tool using the code snippet
10424     for ac_prog in uname
10425 do
10426   # Extract the first word of "$ac_prog", so it can be a program name with args.
10427 set dummy $ac_prog; ac_word=$2
10428 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10429 $as_echo_n "checking for $ac_word... " >&6; }
10430 if ${ac_cv_path_UNAME+:} false; then :
10431   $as_echo_n "(cached) " >&6
10432 else
10433   case $UNAME in
10434   [\\/]* | ?:[\\/]*)
10435   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10436   ;;
10437   *)
10438   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10439 for as_dir in $PATH
10440 do
10441   IFS=$as_save_IFS
10442   test -z "$as_dir" && as_dir=.
10443     for ac_exec_ext in '' $ac_executable_extensions; do
10444   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10445     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10446     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10447     break 2
10448   fi
10449 done
10450   done
10451 IFS=$as_save_IFS
10452 
10453   ;;
10454 esac
10455 fi
10456 UNAME=$ac_cv_path_UNAME
10457 if test -n "$UNAME"; then
10458   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10459 $as_echo "$UNAME" >&6; }
10460 else
10461   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10462 $as_echo "no" >&6; }
10463 fi
10464 
10465 
10466   test -n "$UNAME" && break
10467 done
10468 
10469   else
10470     # The variable is set, but is it from the command line or the environment?
10471 
10472     # Try to remove the string !UNAME! from our list.
10473     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
10474     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10475       # If it failed, the variable was not from the command line. Ignore it,
10476       # but warn the user (except for BASH, which is always set by the calling BASH).
10477       if test "xUNAME" != xBASH; then
10478         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
10479 $as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
10480       fi
10481       # Try to locate tool using the code snippet
10482       for ac_prog in uname
10483 do
10484   # Extract the first word of "$ac_prog", so it can be a program name with args.
10485 set dummy $ac_prog; ac_word=$2
10486 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10487 $as_echo_n "checking for $ac_word... " >&6; }
10488 if ${ac_cv_path_UNAME+:} false; then :
10489   $as_echo_n "(cached) " >&6
10490 else
10491   case $UNAME in
10492   [\\/]* | ?:[\\/]*)
10493   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10494   ;;
10495   *)
10496   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10497 for as_dir in $PATH
10498 do
10499   IFS=$as_save_IFS
10500   test -z "$as_dir" && as_dir=.
10501     for ac_exec_ext in '' $ac_executable_extensions; do
10502   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10503     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10504     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10505     break 2
10506   fi
10507 done
10508   done
10509 IFS=$as_save_IFS
10510 
10511   ;;
10512 esac
10513 fi
10514 UNAME=$ac_cv_path_UNAME
10515 if test -n "$UNAME"; then
10516   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10517 $as_echo "$UNAME" >&6; }
10518 else
10519   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10520 $as_echo "no" >&6; }
10521 fi
10522 
10523 
10524   test -n "$UNAME" && break
10525 done
10526 
10527     else
10528       # If it succeeded, then it was overridden by the user. We will use it
10529       # for the tool.
10530 
10531       # First remove it from the list of overridden variables, so we can test
10532       # for unknown variables in the end.
10533       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10534 
10535       # Check if the provided tool contains a complete path.
10536       tool_specified="$UNAME"
10537       tool_basename="${tool_specified##*/}"
10538       if test "x$tool_basename" = "x$tool_specified"; then
10539         # A command without a complete path is provided, search $PATH.
10540         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
10541 $as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
10542         # Extract the first word of "$tool_basename", so it can be a program name with args.
10543 set dummy $tool_basename; ac_word=$2
10544 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10545 $as_echo_n "checking for $ac_word... " >&6; }
10546 if ${ac_cv_path_UNAME+:} false; then :
10547   $as_echo_n "(cached) " >&6
10548 else
10549   case $UNAME in
10550   [\\/]* | ?:[\\/]*)
10551   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10552   ;;
10553   *)
10554   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10555 for as_dir in $PATH
10556 do
10557   IFS=$as_save_IFS
10558   test -z "$as_dir" && as_dir=.
10559     for ac_exec_ext in '' $ac_executable_extensions; do
10560   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10561     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10562     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10563     break 2
10564   fi
10565 done
10566   done
10567 IFS=$as_save_IFS
10568 
10569   ;;
10570 esac
10571 fi
10572 UNAME=$ac_cv_path_UNAME
10573 if test -n "$UNAME"; then
10574   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10575 $as_echo "$UNAME" >&6; }
10576 else
10577   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10578 $as_echo "no" >&6; }
10579 fi
10580 
10581 
10582         if test "x$UNAME" = x; then
10583           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10584         fi
10585       else
10586         # Otherwise we believe it is a complete path. Use it as it is.
10587         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
10588 $as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
10589         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
10590 $as_echo_n "checking for UNAME... " >&6; }
10591         if test ! -x "$tool_specified"; then
10592           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10593 $as_echo "not found" >&6; }
10594           as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
10595         fi
10596         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10597 $as_echo "$tool_specified" >&6; }
10598       fi
10599     fi
10600   fi
10601 
10602 
10603 
10604   if test "x$UNAME" = x; then
10605     as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
10606   fi
10607 
10608 
10609 
10610 
10611 
10612   # Publish this variable in the help.
10613 
10614 
10615   if test "x$UNIQ" = x; then
10616     # The variable is not set by user, try to locate tool using the code snippet
10617     for ac_prog in uniq
10618 do
10619   # Extract the first word of "$ac_prog", so it can be a program name with args.
10620 set dummy $ac_prog; ac_word=$2
10621 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10622 $as_echo_n "checking for $ac_word... " >&6; }
10623 if ${ac_cv_path_UNIQ+:} false; then :
10624   $as_echo_n "(cached) " >&6
10625 else
10626   case $UNIQ in
10627   [\\/]* | ?:[\\/]*)
10628   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10629   ;;
10630   *)
10631   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10632 for as_dir in $PATH
10633 do
10634   IFS=$as_save_IFS
10635   test -z "$as_dir" && as_dir=.
10636     for ac_exec_ext in '' $ac_executable_extensions; do
10637   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10638     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10639     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10640     break 2
10641   fi
10642 done
10643   done
10644 IFS=$as_save_IFS
10645 
10646   ;;
10647 esac
10648 fi
10649 UNIQ=$ac_cv_path_UNIQ
10650 if test -n "$UNIQ"; then
10651   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10652 $as_echo "$UNIQ" >&6; }
10653 else
10654   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10655 $as_echo "no" >&6; }
10656 fi
10657 
10658 
10659   test -n "$UNIQ" && break
10660 done
10661 
10662   else
10663     # The variable is set, but is it from the command line or the environment?
10664 
10665     # Try to remove the string !UNIQ! from our list.
10666     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
10667     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10668       # If it failed, the variable was not from the command line. Ignore it,
10669       # but warn the user (except for BASH, which is always set by the calling BASH).
10670       if test "xUNIQ" != xBASH; then
10671         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
10672 $as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
10673       fi
10674       # Try to locate tool using the code snippet
10675       for ac_prog in uniq
10676 do
10677   # Extract the first word of "$ac_prog", so it can be a program name with args.
10678 set dummy $ac_prog; ac_word=$2
10679 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10680 $as_echo_n "checking for $ac_word... " >&6; }
10681 if ${ac_cv_path_UNIQ+:} false; then :
10682   $as_echo_n "(cached) " >&6
10683 else
10684   case $UNIQ in
10685   [\\/]* | ?:[\\/]*)
10686   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10687   ;;
10688   *)
10689   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10690 for as_dir in $PATH
10691 do
10692   IFS=$as_save_IFS
10693   test -z "$as_dir" && as_dir=.
10694     for ac_exec_ext in '' $ac_executable_extensions; do
10695   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10696     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10697     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10698     break 2
10699   fi
10700 done
10701   done
10702 IFS=$as_save_IFS
10703 
10704   ;;
10705 esac
10706 fi
10707 UNIQ=$ac_cv_path_UNIQ
10708 if test -n "$UNIQ"; then
10709   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10710 $as_echo "$UNIQ" >&6; }
10711 else
10712   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10713 $as_echo "no" >&6; }
10714 fi
10715 
10716 
10717   test -n "$UNIQ" && break
10718 done
10719 
10720     else
10721       # If it succeeded, then it was overridden by the user. We will use it
10722       # for the tool.
10723 
10724       # First remove it from the list of overridden variables, so we can test
10725       # for unknown variables in the end.
10726       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10727 
10728       # Check if the provided tool contains a complete path.
10729       tool_specified="$UNIQ"
10730       tool_basename="${tool_specified##*/}"
10731       if test "x$tool_basename" = "x$tool_specified"; then
10732         # A command without a complete path is provided, search $PATH.
10733         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
10734 $as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
10735         # Extract the first word of "$tool_basename", so it can be a program name with args.
10736 set dummy $tool_basename; ac_word=$2
10737 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10738 $as_echo_n "checking for $ac_word... " >&6; }
10739 if ${ac_cv_path_UNIQ+:} false; then :
10740   $as_echo_n "(cached) " >&6
10741 else
10742   case $UNIQ in
10743   [\\/]* | ?:[\\/]*)
10744   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10745   ;;
10746   *)
10747   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10748 for as_dir in $PATH
10749 do
10750   IFS=$as_save_IFS
10751   test -z "$as_dir" && as_dir=.
10752     for ac_exec_ext in '' $ac_executable_extensions; do
10753   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10754     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10755     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10756     break 2
10757   fi
10758 done
10759   done
10760 IFS=$as_save_IFS
10761 
10762   ;;
10763 esac
10764 fi
10765 UNIQ=$ac_cv_path_UNIQ
10766 if test -n "$UNIQ"; then
10767   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10768 $as_echo "$UNIQ" >&6; }
10769 else
10770   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10771 $as_echo "no" >&6; }
10772 fi
10773 
10774 
10775         if test "x$UNIQ" = x; then
10776           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10777         fi
10778       else
10779         # Otherwise we believe it is a complete path. Use it as it is.
10780         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
10781 $as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
10782         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
10783 $as_echo_n "checking for UNIQ... " >&6; }
10784         if test ! -x "$tool_specified"; then
10785           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10786 $as_echo "not found" >&6; }
10787           as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
10788         fi
10789         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10790 $as_echo "$tool_specified" >&6; }
10791       fi
10792     fi
10793   fi
10794 
10795 
10796 
10797   if test "x$UNIQ" = x; then
10798     as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
10799   fi
10800 
10801 
10802 
10803 
10804 
10805   # Publish this variable in the help.
10806 
10807 
10808   if test "x$WC" = x; then
10809     # The variable is not set by user, try to locate tool using the code snippet
10810     for ac_prog in wc
10811 do
10812   # Extract the first word of "$ac_prog", so it can be a program name with args.
10813 set dummy $ac_prog; ac_word=$2
10814 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10815 $as_echo_n "checking for $ac_word... " >&6; }
10816 if ${ac_cv_path_WC+:} false; then :
10817   $as_echo_n "(cached) " >&6
10818 else
10819   case $WC in
10820   [\\/]* | ?:[\\/]*)
10821   ac_cv_path_WC="$WC" # Let the user override the test with a path.
10822   ;;
10823   *)
10824   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10825 for as_dir in $PATH
10826 do
10827   IFS=$as_save_IFS
10828   test -z "$as_dir" && as_dir=.
10829     for ac_exec_ext in '' $ac_executable_extensions; do
10830   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10831     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10832     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10833     break 2
10834   fi
10835 done
10836   done
10837 IFS=$as_save_IFS
10838 
10839   ;;
10840 esac
10841 fi
10842 WC=$ac_cv_path_WC
10843 if test -n "$WC"; then
10844   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10845 $as_echo "$WC" >&6; }
10846 else
10847   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10848 $as_echo "no" >&6; }
10849 fi
10850 
10851 
10852   test -n "$WC" && break
10853 done
10854 
10855   else
10856     # The variable is set, but is it from the command line or the environment?
10857 
10858     # Try to remove the string !WC! from our list.
10859     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
10860     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10861       # If it failed, the variable was not from the command line. Ignore it,
10862       # but warn the user (except for BASH, which is always set by the calling BASH).
10863       if test "xWC" != xBASH; then
10864         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
10865 $as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
10866       fi
10867       # Try to locate tool using the code snippet
10868       for ac_prog in wc
10869 do
10870   # Extract the first word of "$ac_prog", so it can be a program name with args.
10871 set dummy $ac_prog; ac_word=$2
10872 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10873 $as_echo_n "checking for $ac_word... " >&6; }
10874 if ${ac_cv_path_WC+:} false; then :
10875   $as_echo_n "(cached) " >&6
10876 else
10877   case $WC in
10878   [\\/]* | ?:[\\/]*)
10879   ac_cv_path_WC="$WC" # Let the user override the test with a path.
10880   ;;
10881   *)
10882   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10883 for as_dir in $PATH
10884 do
10885   IFS=$as_save_IFS
10886   test -z "$as_dir" && as_dir=.
10887     for ac_exec_ext in '' $ac_executable_extensions; do
10888   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10889     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10890     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10891     break 2
10892   fi
10893 done
10894   done
10895 IFS=$as_save_IFS
10896 
10897   ;;
10898 esac
10899 fi
10900 WC=$ac_cv_path_WC
10901 if test -n "$WC"; then
10902   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10903 $as_echo "$WC" >&6; }
10904 else
10905   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10906 $as_echo "no" >&6; }
10907 fi
10908 
10909 
10910   test -n "$WC" && break
10911 done
10912 
10913     else
10914       # If it succeeded, then it was overridden by the user. We will use it
10915       # for the tool.
10916 
10917       # First remove it from the list of overridden variables, so we can test
10918       # for unknown variables in the end.
10919       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10920 
10921       # Check if the provided tool contains a complete path.
10922       tool_specified="$WC"
10923       tool_basename="${tool_specified##*/}"
10924       if test "x$tool_basename" = "x$tool_specified"; then
10925         # A command without a complete path is provided, search $PATH.
10926         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
10927 $as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
10928         # Extract the first word of "$tool_basename", so it can be a program name with args.
10929 set dummy $tool_basename; ac_word=$2
10930 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10931 $as_echo_n "checking for $ac_word... " >&6; }
10932 if ${ac_cv_path_WC+:} false; then :
10933   $as_echo_n "(cached) " >&6
10934 else
10935   case $WC in
10936   [\\/]* | ?:[\\/]*)
10937   ac_cv_path_WC="$WC" # Let the user override the test with a path.
10938   ;;
10939   *)
10940   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10941 for as_dir in $PATH
10942 do
10943   IFS=$as_save_IFS
10944   test -z "$as_dir" && as_dir=.
10945     for ac_exec_ext in '' $ac_executable_extensions; do
10946   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10947     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10948     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10949     break 2
10950   fi
10951 done
10952   done
10953 IFS=$as_save_IFS
10954 
10955   ;;
10956 esac
10957 fi
10958 WC=$ac_cv_path_WC
10959 if test -n "$WC"; then
10960   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10961 $as_echo "$WC" >&6; }
10962 else
10963   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10964 $as_echo "no" >&6; }
10965 fi
10966 
10967 
10968         if test "x$WC" = x; then
10969           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10970         fi
10971       else
10972         # Otherwise we believe it is a complete path. Use it as it is.
10973         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
10974 $as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
10975         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
10976 $as_echo_n "checking for WC... " >&6; }
10977         if test ! -x "$tool_specified"; then
10978           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10979 $as_echo "not found" >&6; }
10980           as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
10981         fi
10982         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10983 $as_echo "$tool_specified" >&6; }
10984       fi
10985     fi
10986   fi
10987 
10988 
10989 
10990   if test "x$WC" = x; then
10991     as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
10992   fi
10993 
10994 
10995 
10996 
10997 
10998   # Publish this variable in the help.
10999 
11000 
11001   if test "x$WHICH" = x; then
11002     # The variable is not set by user, try to locate tool using the code snippet
11003     for ac_prog in which
11004 do
11005   # Extract the first word of "$ac_prog", so it can be a program name with args.
11006 set dummy $ac_prog; ac_word=$2
11007 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11008 $as_echo_n "checking for $ac_word... " >&6; }
11009 if ${ac_cv_path_WHICH+:} false; then :
11010   $as_echo_n "(cached) " >&6
11011 else
11012   case $WHICH in
11013   [\\/]* | ?:[\\/]*)
11014   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11015   ;;
11016   *)
11017   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11018 for as_dir in $PATH
11019 do
11020   IFS=$as_save_IFS
11021   test -z "$as_dir" && as_dir=.
11022     for ac_exec_ext in '' $ac_executable_extensions; do
11023   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11024     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11025     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11026     break 2
11027   fi
11028 done
11029   done
11030 IFS=$as_save_IFS
11031 
11032   ;;
11033 esac
11034 fi
11035 WHICH=$ac_cv_path_WHICH
11036 if test -n "$WHICH"; then
11037   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11038 $as_echo "$WHICH" >&6; }
11039 else
11040   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11041 $as_echo "no" >&6; }
11042 fi
11043 
11044 
11045   test -n "$WHICH" && break
11046 done
11047 
11048   else
11049     # The variable is set, but is it from the command line or the environment?
11050 
11051     # Try to remove the string !WHICH! from our list.
11052     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
11053     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11054       # If it failed, the variable was not from the command line. Ignore it,
11055       # but warn the user (except for BASH, which is always set by the calling BASH).
11056       if test "xWHICH" != xBASH; then
11057         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
11058 $as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
11059       fi
11060       # Try to locate tool using the code snippet
11061       for ac_prog in which
11062 do
11063   # Extract the first word of "$ac_prog", so it can be a program name with args.
11064 set dummy $ac_prog; ac_word=$2
11065 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11066 $as_echo_n "checking for $ac_word... " >&6; }
11067 if ${ac_cv_path_WHICH+:} false; then :
11068   $as_echo_n "(cached) " >&6
11069 else
11070   case $WHICH in
11071   [\\/]* | ?:[\\/]*)
11072   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11073   ;;
11074   *)
11075   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11076 for as_dir in $PATH
11077 do
11078   IFS=$as_save_IFS
11079   test -z "$as_dir" && as_dir=.
11080     for ac_exec_ext in '' $ac_executable_extensions; do
11081   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11082     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11083     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11084     break 2
11085   fi
11086 done
11087   done
11088 IFS=$as_save_IFS
11089 
11090   ;;
11091 esac
11092 fi
11093 WHICH=$ac_cv_path_WHICH
11094 if test -n "$WHICH"; then
11095   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11096 $as_echo "$WHICH" >&6; }
11097 else
11098   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11099 $as_echo "no" >&6; }
11100 fi
11101 
11102 
11103   test -n "$WHICH" && break
11104 done
11105 
11106     else
11107       # If it succeeded, then it was overridden by the user. We will use it
11108       # for the tool.
11109 
11110       # First remove it from the list of overridden variables, so we can test
11111       # for unknown variables in the end.
11112       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11113 
11114       # Check if the provided tool contains a complete path.
11115       tool_specified="$WHICH"
11116       tool_basename="${tool_specified##*/}"
11117       if test "x$tool_basename" = "x$tool_specified"; then
11118         # A command without a complete path is provided, search $PATH.
11119         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
11120 $as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
11121         # Extract the first word of "$tool_basename", so it can be a program name with args.
11122 set dummy $tool_basename; ac_word=$2
11123 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11124 $as_echo_n "checking for $ac_word... " >&6; }
11125 if ${ac_cv_path_WHICH+:} false; then :
11126   $as_echo_n "(cached) " >&6
11127 else
11128   case $WHICH in
11129   [\\/]* | ?:[\\/]*)
11130   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11131   ;;
11132   *)
11133   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11134 for as_dir in $PATH
11135 do
11136   IFS=$as_save_IFS
11137   test -z "$as_dir" && as_dir=.
11138     for ac_exec_ext in '' $ac_executable_extensions; do
11139   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11140     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11141     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11142     break 2
11143   fi
11144 done
11145   done
11146 IFS=$as_save_IFS
11147 
11148   ;;
11149 esac
11150 fi
11151 WHICH=$ac_cv_path_WHICH
11152 if test -n "$WHICH"; then
11153   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11154 $as_echo "$WHICH" >&6; }
11155 else
11156   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11157 $as_echo "no" >&6; }
11158 fi
11159 
11160 
11161         if test "x$WHICH" = x; then
11162           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11163         fi
11164       else
11165         # Otherwise we believe it is a complete path. Use it as it is.
11166         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
11167 $as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
11168         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
11169 $as_echo_n "checking for WHICH... " >&6; }
11170         if test ! -x "$tool_specified"; then
11171           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11172 $as_echo "not found" >&6; }
11173           as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
11174         fi
11175         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11176 $as_echo "$tool_specified" >&6; }
11177       fi
11178     fi
11179   fi
11180 
11181 
11182 
11183   if test "x$WHICH" = x; then
11184     as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
11185   fi
11186 
11187 
11188 
11189 
11190 
11191   # Publish this variable in the help.
11192 
11193 
11194   if test "x$XARGS" = x; then
11195     # The variable is not set by user, try to locate tool using the code snippet
11196     for ac_prog in xargs
11197 do
11198   # Extract the first word of "$ac_prog", so it can be a program name with args.
11199 set dummy $ac_prog; ac_word=$2
11200 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11201 $as_echo_n "checking for $ac_word... " >&6; }
11202 if ${ac_cv_path_XARGS+:} false; then :
11203   $as_echo_n "(cached) " >&6
11204 else
11205   case $XARGS in
11206   [\\/]* | ?:[\\/]*)
11207   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11208   ;;
11209   *)
11210   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11211 for as_dir in $PATH
11212 do
11213   IFS=$as_save_IFS
11214   test -z "$as_dir" && as_dir=.
11215     for ac_exec_ext in '' $ac_executable_extensions; do
11216   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11217     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11218     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11219     break 2
11220   fi
11221 done
11222   done
11223 IFS=$as_save_IFS
11224 
11225   ;;
11226 esac
11227 fi
11228 XARGS=$ac_cv_path_XARGS
11229 if test -n "$XARGS"; then
11230   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11231 $as_echo "$XARGS" >&6; }
11232 else
11233   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11234 $as_echo "no" >&6; }
11235 fi
11236 
11237 
11238   test -n "$XARGS" && break
11239 done
11240 
11241   else
11242     # The variable is set, but is it from the command line or the environment?
11243 
11244     # Try to remove the string !XARGS! from our list.
11245     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
11246     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11247       # If it failed, the variable was not from the command line. Ignore it,
11248       # but warn the user (except for BASH, which is always set by the calling BASH).
11249       if test "xXARGS" != xBASH; then
11250         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
11251 $as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
11252       fi
11253       # Try to locate tool using the code snippet
11254       for ac_prog in xargs
11255 do
11256   # Extract the first word of "$ac_prog", so it can be a program name with args.
11257 set dummy $ac_prog; ac_word=$2
11258 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11259 $as_echo_n "checking for $ac_word... " >&6; }
11260 if ${ac_cv_path_XARGS+:} false; then :
11261   $as_echo_n "(cached) " >&6
11262 else
11263   case $XARGS in
11264   [\\/]* | ?:[\\/]*)
11265   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11266   ;;
11267   *)
11268   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11269 for as_dir in $PATH
11270 do
11271   IFS=$as_save_IFS
11272   test -z "$as_dir" && as_dir=.
11273     for ac_exec_ext in '' $ac_executable_extensions; do
11274   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11275     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11276     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11277     break 2
11278   fi
11279 done
11280   done
11281 IFS=$as_save_IFS
11282 
11283   ;;
11284 esac
11285 fi
11286 XARGS=$ac_cv_path_XARGS
11287 if test -n "$XARGS"; then
11288   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11289 $as_echo "$XARGS" >&6; }
11290 else
11291   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11292 $as_echo "no" >&6; }
11293 fi
11294 
11295 
11296   test -n "$XARGS" && break
11297 done
11298 
11299     else
11300       # If it succeeded, then it was overridden by the user. We will use it
11301       # for the tool.
11302 
11303       # First remove it from the list of overridden variables, so we can test
11304       # for unknown variables in the end.
11305       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11306 
11307       # Check if the provided tool contains a complete path.
11308       tool_specified="$XARGS"
11309       tool_basename="${tool_specified##*/}"
11310       if test "x$tool_basename" = "x$tool_specified"; then
11311         # A command without a complete path is provided, search $PATH.
11312         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
11313 $as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
11314         # Extract the first word of "$tool_basename", so it can be a program name with args.
11315 set dummy $tool_basename; ac_word=$2
11316 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11317 $as_echo_n "checking for $ac_word... " >&6; }
11318 if ${ac_cv_path_XARGS+:} false; then :
11319   $as_echo_n "(cached) " >&6
11320 else
11321   case $XARGS in
11322   [\\/]* | ?:[\\/]*)
11323   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11324   ;;
11325   *)
11326   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11327 for as_dir in $PATH
11328 do
11329   IFS=$as_save_IFS
11330   test -z "$as_dir" && as_dir=.
11331     for ac_exec_ext in '' $ac_executable_extensions; do
11332   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11333     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11334     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11335     break 2
11336   fi
11337 done
11338   done
11339 IFS=$as_save_IFS
11340 
11341   ;;
11342 esac
11343 fi
11344 XARGS=$ac_cv_path_XARGS
11345 if test -n "$XARGS"; then
11346   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11347 $as_echo "$XARGS" >&6; }
11348 else
11349   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11350 $as_echo "no" >&6; }
11351 fi
11352 
11353 
11354         if test "x$XARGS" = x; then
11355           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11356         fi
11357       else
11358         # Otherwise we believe it is a complete path. Use it as it is.
11359         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
11360 $as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
11361         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
11362 $as_echo_n "checking for XARGS... " >&6; }
11363         if test ! -x "$tool_specified"; then
11364           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11365 $as_echo "not found" >&6; }
11366           as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
11367         fi
11368         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11369 $as_echo "$tool_specified" >&6; }
11370       fi
11371     fi
11372   fi
11373 
11374 
11375 
11376   if test "x$XARGS" = x; then
11377     as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
11378   fi
11379 
11380 
11381 
11382   # Then required tools that require some special treatment.
11383 
11384 
11385   # Publish this variable in the help.
11386 
11387 
11388   if test "x$AWK" = x; then
11389     # The variable is not set by user, try to locate tool using the code snippet
11390     for ac_prog in gawk mawk nawk awk
11391 do
11392   # Extract the first word of "$ac_prog", so it can be a program name with args.
11393 set dummy $ac_prog; ac_word=$2
11394 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11395 $as_echo_n "checking for $ac_word... " >&6; }
11396 if ${ac_cv_prog_AWK+:} false; then :
11397   $as_echo_n "(cached) " >&6
11398 else
11399   if test -n "$AWK"; then
11400   ac_cv_prog_AWK="$AWK" # Let the user override the test.
11401 else
11402 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11403 for as_dir in $PATH
11404 do
11405   IFS=$as_save_IFS
11406   test -z "$as_dir" && as_dir=.
11407     for ac_exec_ext in '' $ac_executable_extensions; do
11408   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11409     ac_cv_prog_AWK="$ac_prog"
11410     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11411     break 2
11412   fi
11413 done
11414   done
11415 IFS=$as_save_IFS
11416 
11417 fi
11418 fi
11419 AWK=$ac_cv_prog_AWK
11420 if test -n "$AWK"; then
11421   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11422 $as_echo "$AWK" >&6; }
11423 else
11424   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11425 $as_echo "no" >&6; }
11426 fi
11427 
11428 
11429   test -n "$AWK" && break
11430 done
11431 
11432   else
11433     # The variable is set, but is it from the command line or the environment?
11434 
11435     # Try to remove the string !AWK! from our list.
11436     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
11437     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11438       # If it failed, the variable was not from the command line. Ignore it,
11439       # but warn the user (except for BASH, which is always set by the calling BASH).
11440       if test "xAWK" != xBASH; then
11441         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
11442 $as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
11443       fi
11444       # Try to locate tool using the code snippet
11445       for ac_prog in gawk mawk nawk awk
11446 do
11447   # Extract the first word of "$ac_prog", so it can be a program name with args.
11448 set dummy $ac_prog; ac_word=$2
11449 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11450 $as_echo_n "checking for $ac_word... " >&6; }
11451 if ${ac_cv_prog_AWK+:} false; then :
11452   $as_echo_n "(cached) " >&6
11453 else
11454   if test -n "$AWK"; then
11455   ac_cv_prog_AWK="$AWK" # Let the user override the test.
11456 else
11457 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11458 for as_dir in $PATH
11459 do
11460   IFS=$as_save_IFS
11461   test -z "$as_dir" && as_dir=.
11462     for ac_exec_ext in '' $ac_executable_extensions; do
11463   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11464     ac_cv_prog_AWK="$ac_prog"
11465     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11466     break 2
11467   fi
11468 done
11469   done
11470 IFS=$as_save_IFS
11471 
11472 fi
11473 fi
11474 AWK=$ac_cv_prog_AWK
11475 if test -n "$AWK"; then
11476   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11477 $as_echo "$AWK" >&6; }
11478 else
11479   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11480 $as_echo "no" >&6; }
11481 fi
11482 
11483 
11484   test -n "$AWK" && break
11485 done
11486 
11487     else
11488       # If it succeeded, then it was overridden by the user. We will use it
11489       # for the tool.
11490 
11491       # First remove it from the list of overridden variables, so we can test
11492       # for unknown variables in the end.
11493       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11494 
11495       # Check if the provided tool contains a complete path.
11496       tool_specified="$AWK"
11497       tool_basename="${tool_specified##*/}"
11498       if test "x$tool_basename" = "x$tool_specified"; then
11499         # A command without a complete path is provided, search $PATH.
11500         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
11501 $as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
11502         # Extract the first word of "$tool_basename", so it can be a program name with args.
11503 set dummy $tool_basename; ac_word=$2
11504 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11505 $as_echo_n "checking for $ac_word... " >&6; }
11506 if ${ac_cv_path_AWK+:} false; then :
11507   $as_echo_n "(cached) " >&6
11508 else
11509   case $AWK in
11510   [\\/]* | ?:[\\/]*)
11511   ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
11512   ;;
11513   *)
11514   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11515 for as_dir in $PATH
11516 do
11517   IFS=$as_save_IFS
11518   test -z "$as_dir" && as_dir=.
11519     for ac_exec_ext in '' $ac_executable_extensions; do
11520   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11521     ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
11522     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11523     break 2
11524   fi
11525 done
11526   done
11527 IFS=$as_save_IFS
11528 
11529   ;;
11530 esac
11531 fi
11532 AWK=$ac_cv_path_AWK
11533 if test -n "$AWK"; then
11534   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11535 $as_echo "$AWK" >&6; }
11536 else
11537   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11538 $as_echo "no" >&6; }
11539 fi
11540 
11541 
11542         if test "x$AWK" = x; then
11543           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11544         fi
11545       else
11546         # Otherwise we believe it is a complete path. Use it as it is.
11547         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
11548 $as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
11549         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
11550 $as_echo_n "checking for AWK... " >&6; }
11551         if test ! -x "$tool_specified"; then
11552           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11553 $as_echo "not found" >&6; }
11554           as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
11555         fi
11556         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11557 $as_echo "$tool_specified" >&6; }
11558       fi
11559     fi
11560   fi
11561 
11562 
11563   if test "x$AWK" = x; then
11564     as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
11565   fi
11566 
11567 
11568 
11569 
11570   # Publish this variable in the help.
11571 
11572 
11573   if test "x$GREP" = x; then
11574     # The variable is not set by user, try to locate tool using the code snippet
11575     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11576 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11577 if ${ac_cv_path_GREP+:} false; then :
11578   $as_echo_n "(cached) " >&6
11579 else
11580   if test -z "$GREP"; then
11581   ac_path_GREP_found=false
11582   # Loop through the user's path and test for each of PROGNAME-LIST
11583   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11584 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11585 do
11586   IFS=$as_save_IFS
11587   test -z "$as_dir" && as_dir=.
11588     for ac_prog in grep ggrep; do
11589     for ac_exec_ext in '' $ac_executable_extensions; do
11590       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11591       as_fn_executable_p "$ac_path_GREP" || continue
11592 # Check for GNU ac_path_GREP and select it if it is found.
11593   # Check for GNU $ac_path_GREP
11594 case `"$ac_path_GREP" --version 2>&1` in
11595 *GNU*)
11596   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11597 *)
11598   ac_count=0
11599   $as_echo_n 0123456789 >"conftest.in"
11600   while :
11601   do
11602     cat "conftest.in" "conftest.in" >"conftest.tmp"
11603     mv "conftest.tmp" "conftest.in"
11604     cp "conftest.in" "conftest.nl"
11605     $as_echo 'GREP' >> "conftest.nl"
11606     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11607     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11608     as_fn_arith $ac_count + 1 && ac_count=$as_val
11609     if test $ac_count -gt ${ac_path_GREP_max-0}; then
11610       # Best one so far, save it but keep looking for a better one
11611       ac_cv_path_GREP="$ac_path_GREP"
11612       ac_path_GREP_max=$ac_count
11613     fi
11614     # 10*(2^10) chars as input seems more than enough
11615     test $ac_count -gt 10 && break
11616   done
11617   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11618 esac
11619 
11620       $ac_path_GREP_found && break 3
11621     done
11622   done
11623   done
11624 IFS=$as_save_IFS
11625   if test -z "$ac_cv_path_GREP"; then
11626     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11627   fi
11628 else
11629   ac_cv_path_GREP=$GREP
11630 fi
11631 
11632 fi
11633 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11634 $as_echo "$ac_cv_path_GREP" >&6; }
11635  GREP="$ac_cv_path_GREP"
11636 
11637 
11638   else
11639     # The variable is set, but is it from the command line or the environment?
11640 
11641     # Try to remove the string !GREP! from our list.
11642     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
11643     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11644       # If it failed, the variable was not from the command line. Ignore it,
11645       # but warn the user (except for BASH, which is always set by the calling BASH).
11646       if test "xGREP" != xBASH; then
11647         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
11648 $as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
11649       fi
11650       # Try to locate tool using the code snippet
11651       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11652 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11653 if ${ac_cv_path_GREP+:} false; then :
11654   $as_echo_n "(cached) " >&6
11655 else
11656   if test -z "$GREP"; then
11657   ac_path_GREP_found=false
11658   # Loop through the user's path and test for each of PROGNAME-LIST
11659   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11660 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11661 do
11662   IFS=$as_save_IFS
11663   test -z "$as_dir" && as_dir=.
11664     for ac_prog in grep ggrep; do
11665     for ac_exec_ext in '' $ac_executable_extensions; do
11666       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11667       as_fn_executable_p "$ac_path_GREP" || continue
11668 # Check for GNU ac_path_GREP and select it if it is found.
11669   # Check for GNU $ac_path_GREP
11670 case `"$ac_path_GREP" --version 2>&1` in
11671 *GNU*)
11672   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11673 *)
11674   ac_count=0
11675   $as_echo_n 0123456789 >"conftest.in"
11676   while :
11677   do
11678     cat "conftest.in" "conftest.in" >"conftest.tmp"
11679     mv "conftest.tmp" "conftest.in"
11680     cp "conftest.in" "conftest.nl"
11681     $as_echo 'GREP' >> "conftest.nl"
11682     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11683     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11684     as_fn_arith $ac_count + 1 && ac_count=$as_val
11685     if test $ac_count -gt ${ac_path_GREP_max-0}; then
11686       # Best one so far, save it but keep looking for a better one
11687       ac_cv_path_GREP="$ac_path_GREP"
11688       ac_path_GREP_max=$ac_count
11689     fi
11690     # 10*(2^10) chars as input seems more than enough
11691     test $ac_count -gt 10 && break
11692   done
11693   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11694 esac
11695 
11696       $ac_path_GREP_found && break 3
11697     done
11698   done
11699   done
11700 IFS=$as_save_IFS
11701   if test -z "$ac_cv_path_GREP"; then
11702     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11703   fi
11704 else
11705   ac_cv_path_GREP=$GREP
11706 fi
11707 
11708 fi
11709 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11710 $as_echo "$ac_cv_path_GREP" >&6; }
11711  GREP="$ac_cv_path_GREP"
11712 
11713 
11714     else
11715       # If it succeeded, then it was overridden by the user. We will use it
11716       # for the tool.
11717 
11718       # First remove it from the list of overridden variables, so we can test
11719       # for unknown variables in the end.
11720       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11721 
11722       # Check if the provided tool contains a complete path.
11723       tool_specified="$GREP"
11724       tool_basename="${tool_specified##*/}"
11725       if test "x$tool_basename" = "x$tool_specified"; then
11726         # A command without a complete path is provided, search $PATH.
11727         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
11728 $as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
11729         # Extract the first word of "$tool_basename", so it can be a program name with args.
11730 set dummy $tool_basename; ac_word=$2
11731 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11732 $as_echo_n "checking for $ac_word... " >&6; }
11733 if ${ac_cv_path_GREP+:} false; then :
11734   $as_echo_n "(cached) " >&6
11735 else
11736   case $GREP in
11737   [\\/]* | ?:[\\/]*)
11738   ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
11739   ;;
11740   *)
11741   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11742 for as_dir in $PATH
11743 do
11744   IFS=$as_save_IFS
11745   test -z "$as_dir" && as_dir=.
11746     for ac_exec_ext in '' $ac_executable_extensions; do
11747   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11748     ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
11749     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11750     break 2
11751   fi
11752 done
11753   done
11754 IFS=$as_save_IFS
11755 
11756   ;;
11757 esac
11758 fi
11759 GREP=$ac_cv_path_GREP
11760 if test -n "$GREP"; then
11761   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
11762 $as_echo "$GREP" >&6; }
11763 else
11764   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11765 $as_echo "no" >&6; }
11766 fi
11767 
11768 
11769         if test "x$GREP" = x; then
11770           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11771         fi
11772       else
11773         # Otherwise we believe it is a complete path. Use it as it is.
11774         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
11775 $as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
11776         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
11777 $as_echo_n "checking for GREP... " >&6; }
11778         if test ! -x "$tool_specified"; then
11779           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11780 $as_echo "not found" >&6; }
11781           as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
11782         fi
11783         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11784 $as_echo "$tool_specified" >&6; }
11785       fi
11786     fi
11787   fi
11788 
11789 
11790   if test "x$GREP" = x; then
11791     as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
11792   fi
11793 
11794 
11795 
11796 
11797   # Publish this variable in the help.
11798 
11799 
11800   if test "x$EGREP" = x; then
11801     # The variable is not set by user, try to locate tool using the code snippet
11802     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11803 $as_echo_n "checking for egrep... " >&6; }
11804 if ${ac_cv_path_EGREP+:} false; then :
11805   $as_echo_n "(cached) " >&6
11806 else
11807   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11808    then ac_cv_path_EGREP="$GREP -E"
11809    else
11810      if test -z "$EGREP"; then
11811   ac_path_EGREP_found=false
11812   # Loop through the user's path and test for each of PROGNAME-LIST
11813   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11814 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11815 do
11816   IFS=$as_save_IFS
11817   test -z "$as_dir" && as_dir=.
11818     for ac_prog in egrep; do
11819     for ac_exec_ext in '' $ac_executable_extensions; do
11820       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11821       as_fn_executable_p "$ac_path_EGREP" || continue
11822 # Check for GNU ac_path_EGREP and select it if it is found.
11823   # Check for GNU $ac_path_EGREP
11824 case `"$ac_path_EGREP" --version 2>&1` in
11825 *GNU*)
11826   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11827 *)
11828   ac_count=0
11829   $as_echo_n 0123456789 >"conftest.in"
11830   while :
11831   do
11832     cat "conftest.in" "conftest.in" >"conftest.tmp"
11833     mv "conftest.tmp" "conftest.in"
11834     cp "conftest.in" "conftest.nl"
11835     $as_echo 'EGREP' >> "conftest.nl"
11836     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11837     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11838     as_fn_arith $ac_count + 1 && ac_count=$as_val
11839     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11840       # Best one so far, save it but keep looking for a better one
11841       ac_cv_path_EGREP="$ac_path_EGREP"
11842       ac_path_EGREP_max=$ac_count
11843     fi
11844     # 10*(2^10) chars as input seems more than enough
11845     test $ac_count -gt 10 && break
11846   done
11847   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11848 esac
11849 
11850       $ac_path_EGREP_found && break 3
11851     done
11852   done
11853   done
11854 IFS=$as_save_IFS
11855   if test -z "$ac_cv_path_EGREP"; then
11856     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11857   fi
11858 else
11859   ac_cv_path_EGREP=$EGREP
11860 fi
11861 
11862    fi
11863 fi
11864 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11865 $as_echo "$ac_cv_path_EGREP" >&6; }
11866  EGREP="$ac_cv_path_EGREP"
11867 
11868 
11869   else
11870     # The variable is set, but is it from the command line or the environment?
11871 
11872     # Try to remove the string !EGREP! from our list.
11873     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
11874     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11875       # If it failed, the variable was not from the command line. Ignore it,
11876       # but warn the user (except for BASH, which is always set by the calling BASH).
11877       if test "xEGREP" != xBASH; then
11878         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
11879 $as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
11880       fi
11881       # Try to locate tool using the code snippet
11882       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11883 $as_echo_n "checking for egrep... " >&6; }
11884 if ${ac_cv_path_EGREP+:} false; then :
11885   $as_echo_n "(cached) " >&6
11886 else
11887   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11888    then ac_cv_path_EGREP="$GREP -E"
11889    else
11890      if test -z "$EGREP"; then
11891   ac_path_EGREP_found=false
11892   # Loop through the user's path and test for each of PROGNAME-LIST
11893   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11894 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11895 do
11896   IFS=$as_save_IFS
11897   test -z "$as_dir" && as_dir=.
11898     for ac_prog in egrep; do
11899     for ac_exec_ext in '' $ac_executable_extensions; do
11900       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11901       as_fn_executable_p "$ac_path_EGREP" || continue
11902 # Check for GNU ac_path_EGREP and select it if it is found.
11903   # Check for GNU $ac_path_EGREP
11904 case `"$ac_path_EGREP" --version 2>&1` in
11905 *GNU*)
11906   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11907 *)
11908   ac_count=0
11909   $as_echo_n 0123456789 >"conftest.in"
11910   while :
11911   do
11912     cat "conftest.in" "conftest.in" >"conftest.tmp"
11913     mv "conftest.tmp" "conftest.in"
11914     cp "conftest.in" "conftest.nl"
11915     $as_echo 'EGREP' >> "conftest.nl"
11916     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11917     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11918     as_fn_arith $ac_count + 1 && ac_count=$as_val
11919     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11920       # Best one so far, save it but keep looking for a better one
11921       ac_cv_path_EGREP="$ac_path_EGREP"
11922       ac_path_EGREP_max=$ac_count
11923     fi
11924     # 10*(2^10) chars as input seems more than enough
11925     test $ac_count -gt 10 && break
11926   done
11927   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11928 esac
11929 
11930       $ac_path_EGREP_found && break 3
11931     done
11932   done
11933   done
11934 IFS=$as_save_IFS
11935   if test -z "$ac_cv_path_EGREP"; then
11936     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11937   fi
11938 else
11939   ac_cv_path_EGREP=$EGREP
11940 fi
11941 
11942    fi
11943 fi
11944 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11945 $as_echo "$ac_cv_path_EGREP" >&6; }
11946  EGREP="$ac_cv_path_EGREP"
11947 
11948 
11949     else
11950       # If it succeeded, then it was overridden by the user. We will use it
11951       # for the tool.
11952 
11953       # First remove it from the list of overridden variables, so we can test
11954       # for unknown variables in the end.
11955       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11956 
11957       # Check if the provided tool contains a complete path.
11958       tool_specified="$EGREP"
11959       tool_basename="${tool_specified##*/}"
11960       if test "x$tool_basename" = "x$tool_specified"; then
11961         # A command without a complete path is provided, search $PATH.
11962         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
11963 $as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
11964         # Extract the first word of "$tool_basename", so it can be a program name with args.
11965 set dummy $tool_basename; ac_word=$2
11966 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11967 $as_echo_n "checking for $ac_word... " >&6; }
11968 if ${ac_cv_path_EGREP+:} false; then :
11969   $as_echo_n "(cached) " >&6
11970 else
11971   case $EGREP in
11972   [\\/]* | ?:[\\/]*)
11973   ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
11974   ;;
11975   *)
11976   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11977 for as_dir in $PATH
11978 do
11979   IFS=$as_save_IFS
11980   test -z "$as_dir" && as_dir=.
11981     for ac_exec_ext in '' $ac_executable_extensions; do
11982   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11983     ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
11984     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11985     break 2
11986   fi
11987 done
11988   done
11989 IFS=$as_save_IFS
11990 
11991   ;;
11992 esac
11993 fi
11994 EGREP=$ac_cv_path_EGREP
11995 if test -n "$EGREP"; then
11996   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
11997 $as_echo "$EGREP" >&6; }
11998 else
11999   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12000 $as_echo "no" >&6; }
12001 fi
12002 
12003 
12004         if test "x$EGREP" = x; then
12005           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12006         fi
12007       else
12008         # Otherwise we believe it is a complete path. Use it as it is.
12009         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
12010 $as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
12011         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
12012 $as_echo_n "checking for EGREP... " >&6; }
12013         if test ! -x "$tool_specified"; then
12014           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12015 $as_echo "not found" >&6; }
12016           as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12017         fi
12018         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12019 $as_echo "$tool_specified" >&6; }
12020       fi
12021     fi
12022   fi
12023 
12024 
12025   if test "x$EGREP" = x; then
12026     as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
12027   fi
12028 
12029 
12030 
12031 
12032   # Publish this variable in the help.
12033 
12034 
12035   if test "x$FGREP" = x; then
12036     # The variable is not set by user, try to locate tool using the code snippet
12037     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12038 $as_echo_n "checking for fgrep... " >&6; }
12039 if ${ac_cv_path_FGREP+:} false; then :
12040   $as_echo_n "(cached) " >&6
12041 else
12042   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12043    then ac_cv_path_FGREP="$GREP -F"
12044    else
12045      if test -z "$FGREP"; then
12046   ac_path_FGREP_found=false
12047   # Loop through the user's path and test for each of PROGNAME-LIST
12048   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12049 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12050 do
12051   IFS=$as_save_IFS
12052   test -z "$as_dir" && as_dir=.
12053     for ac_prog in fgrep; do
12054     for ac_exec_ext in '' $ac_executable_extensions; do
12055       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12056       as_fn_executable_p "$ac_path_FGREP" || continue
12057 # Check for GNU ac_path_FGREP and select it if it is found.
12058   # Check for GNU $ac_path_FGREP
12059 case `"$ac_path_FGREP" --version 2>&1` in
12060 *GNU*)
12061   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12062 *)
12063   ac_count=0
12064   $as_echo_n 0123456789 >"conftest.in"
12065   while :
12066   do
12067     cat "conftest.in" "conftest.in" >"conftest.tmp"
12068     mv "conftest.tmp" "conftest.in"
12069     cp "conftest.in" "conftest.nl"
12070     $as_echo 'FGREP' >> "conftest.nl"
12071     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12072     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12073     as_fn_arith $ac_count + 1 && ac_count=$as_val
12074     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12075       # Best one so far, save it but keep looking for a better one
12076       ac_cv_path_FGREP="$ac_path_FGREP"
12077       ac_path_FGREP_max=$ac_count
12078     fi
12079     # 10*(2^10) chars as input seems more than enough
12080     test $ac_count -gt 10 && break
12081   done
12082   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12083 esac
12084 
12085       $ac_path_FGREP_found && break 3
12086     done
12087   done
12088   done
12089 IFS=$as_save_IFS
12090   if test -z "$ac_cv_path_FGREP"; then
12091     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12092   fi
12093 else
12094   ac_cv_path_FGREP=$FGREP
12095 fi
12096 
12097    fi
12098 fi
12099 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12100 $as_echo "$ac_cv_path_FGREP" >&6; }
12101  FGREP="$ac_cv_path_FGREP"
12102 
12103 
12104   else
12105     # The variable is set, but is it from the command line or the environment?
12106 
12107     # Try to remove the string !FGREP! from our list.
12108     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
12109     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12110       # If it failed, the variable was not from the command line. Ignore it,
12111       # but warn the user (except for BASH, which is always set by the calling BASH).
12112       if test "xFGREP" != xBASH; then
12113         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
12114 $as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
12115       fi
12116       # Try to locate tool using the code snippet
12117       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12118 $as_echo_n "checking for fgrep... " >&6; }
12119 if ${ac_cv_path_FGREP+:} false; then :
12120   $as_echo_n "(cached) " >&6
12121 else
12122   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12123    then ac_cv_path_FGREP="$GREP -F"
12124    else
12125      if test -z "$FGREP"; then
12126   ac_path_FGREP_found=false
12127   # Loop through the user's path and test for each of PROGNAME-LIST
12128   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12129 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12130 do
12131   IFS=$as_save_IFS
12132   test -z "$as_dir" && as_dir=.
12133     for ac_prog in fgrep; do
12134     for ac_exec_ext in '' $ac_executable_extensions; do
12135       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12136       as_fn_executable_p "$ac_path_FGREP" || continue
12137 # Check for GNU ac_path_FGREP and select it if it is found.
12138   # Check for GNU $ac_path_FGREP
12139 case `"$ac_path_FGREP" --version 2>&1` in
12140 *GNU*)
12141   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12142 *)
12143   ac_count=0
12144   $as_echo_n 0123456789 >"conftest.in"
12145   while :
12146   do
12147     cat "conftest.in" "conftest.in" >"conftest.tmp"
12148     mv "conftest.tmp" "conftest.in"
12149     cp "conftest.in" "conftest.nl"
12150     $as_echo 'FGREP' >> "conftest.nl"
12151     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12152     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12153     as_fn_arith $ac_count + 1 && ac_count=$as_val
12154     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12155       # Best one so far, save it but keep looking for a better one
12156       ac_cv_path_FGREP="$ac_path_FGREP"
12157       ac_path_FGREP_max=$ac_count
12158     fi
12159     # 10*(2^10) chars as input seems more than enough
12160     test $ac_count -gt 10 && break
12161   done
12162   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12163 esac
12164 
12165       $ac_path_FGREP_found && break 3
12166     done
12167   done
12168   done
12169 IFS=$as_save_IFS
12170   if test -z "$ac_cv_path_FGREP"; then
12171     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12172   fi
12173 else
12174   ac_cv_path_FGREP=$FGREP
12175 fi
12176 
12177    fi
12178 fi
12179 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12180 $as_echo "$ac_cv_path_FGREP" >&6; }
12181  FGREP="$ac_cv_path_FGREP"
12182 
12183 
12184     else
12185       # If it succeeded, then it was overridden by the user. We will use it
12186       # for the tool.
12187 
12188       # First remove it from the list of overridden variables, so we can test
12189       # for unknown variables in the end.
12190       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12191 
12192       # Check if the provided tool contains a complete path.
12193       tool_specified="$FGREP"
12194       tool_basename="${tool_specified##*/}"
12195       if test "x$tool_basename" = "x$tool_specified"; then
12196         # A command without a complete path is provided, search $PATH.
12197         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
12198 $as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
12199         # Extract the first word of "$tool_basename", so it can be a program name with args.
12200 set dummy $tool_basename; ac_word=$2
12201 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12202 $as_echo_n "checking for $ac_word... " >&6; }
12203 if ${ac_cv_path_FGREP+:} false; then :
12204   $as_echo_n "(cached) " >&6
12205 else
12206   case $FGREP in
12207   [\\/]* | ?:[\\/]*)
12208   ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
12209   ;;
12210   *)
12211   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12212 for as_dir in $PATH
12213 do
12214   IFS=$as_save_IFS
12215   test -z "$as_dir" && as_dir=.
12216     for ac_exec_ext in '' $ac_executable_extensions; do
12217   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12218     ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
12219     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12220     break 2
12221   fi
12222 done
12223   done
12224 IFS=$as_save_IFS
12225 
12226   ;;
12227 esac
12228 fi
12229 FGREP=$ac_cv_path_FGREP
12230 if test -n "$FGREP"; then
12231   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
12232 $as_echo "$FGREP" >&6; }
12233 else
12234   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12235 $as_echo "no" >&6; }
12236 fi
12237 
12238 
12239         if test "x$FGREP" = x; then
12240           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12241         fi
12242       else
12243         # Otherwise we believe it is a complete path. Use it as it is.
12244         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
12245 $as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
12246         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
12247 $as_echo_n "checking for FGREP... " >&6; }
12248         if test ! -x "$tool_specified"; then
12249           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12250 $as_echo "not found" >&6; }
12251           as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12252         fi
12253         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12254 $as_echo "$tool_specified" >&6; }
12255       fi
12256     fi
12257   fi
12258 
12259 
12260   if test "x$FGREP" = x; then
12261     as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
12262   fi
12263 
12264 
12265 
12266 
12267   # Publish this variable in the help.
12268 
12269 
12270   if test "x$SED" = x; then
12271     # The variable is not set by user, try to locate tool using the code snippet
12272     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12273 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12274 if ${ac_cv_path_SED+:} false; then :
12275   $as_echo_n "(cached) " >&6
12276 else
12277             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12278      for ac_i in 1 2 3 4 5 6 7; do
12279        ac_script="$ac_script$as_nl$ac_script"
12280      done
12281      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12282      { ac_script=; unset ac_script;}
12283      if test -z "$SED"; then
12284   ac_path_SED_found=false
12285   # Loop through the user's path and test for each of PROGNAME-LIST
12286   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12287 for as_dir in $PATH
12288 do
12289   IFS=$as_save_IFS
12290   test -z "$as_dir" && as_dir=.
12291     for ac_prog in sed gsed; do
12292     for ac_exec_ext in '' $ac_executable_extensions; do
12293       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12294       as_fn_executable_p "$ac_path_SED" || continue
12295 # Check for GNU ac_path_SED and select it if it is found.
12296   # Check for GNU $ac_path_SED
12297 case `"$ac_path_SED" --version 2>&1` in
12298 *GNU*)
12299   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12300 *)
12301   ac_count=0
12302   $as_echo_n 0123456789 >"conftest.in"
12303   while :
12304   do
12305     cat "conftest.in" "conftest.in" >"conftest.tmp"
12306     mv "conftest.tmp" "conftest.in"
12307     cp "conftest.in" "conftest.nl"
12308     $as_echo '' >> "conftest.nl"
12309     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12310     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12311     as_fn_arith $ac_count + 1 && ac_count=$as_val
12312     if test $ac_count -gt ${ac_path_SED_max-0}; then
12313       # Best one so far, save it but keep looking for a better one
12314       ac_cv_path_SED="$ac_path_SED"
12315       ac_path_SED_max=$ac_count
12316     fi
12317     # 10*(2^10) chars as input seems more than enough
12318     test $ac_count -gt 10 && break
12319   done
12320   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12321 esac
12322 
12323       $ac_path_SED_found && break 3
12324     done
12325   done
12326   done
12327 IFS=$as_save_IFS
12328   if test -z "$ac_cv_path_SED"; then
12329     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12330   fi
12331 else
12332   ac_cv_path_SED=$SED
12333 fi
12334 
12335 fi
12336 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12337 $as_echo "$ac_cv_path_SED" >&6; }
12338  SED="$ac_cv_path_SED"
12339   rm -f conftest.sed
12340 
12341   else
12342     # The variable is set, but is it from the command line or the environment?
12343 
12344     # Try to remove the string !SED! from our list.
12345     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
12346     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12347       # If it failed, the variable was not from the command line. Ignore it,
12348       # but warn the user (except for BASH, which is always set by the calling BASH).
12349       if test "xSED" != xBASH; then
12350         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
12351 $as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
12352       fi
12353       # Try to locate tool using the code snippet
12354       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12355 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12356 if ${ac_cv_path_SED+:} false; then :
12357   $as_echo_n "(cached) " >&6
12358 else
12359             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12360      for ac_i in 1 2 3 4 5 6 7; do
12361        ac_script="$ac_script$as_nl$ac_script"
12362      done
12363      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12364      { ac_script=; unset ac_script;}
12365      if test -z "$SED"; then
12366   ac_path_SED_found=false
12367   # Loop through the user's path and test for each of PROGNAME-LIST
12368   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12369 for as_dir in $PATH
12370 do
12371   IFS=$as_save_IFS
12372   test -z "$as_dir" && as_dir=.
12373     for ac_prog in sed gsed; do
12374     for ac_exec_ext in '' $ac_executable_extensions; do
12375       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12376       as_fn_executable_p "$ac_path_SED" || continue
12377 # Check for GNU ac_path_SED and select it if it is found.
12378   # Check for GNU $ac_path_SED
12379 case `"$ac_path_SED" --version 2>&1` in
12380 *GNU*)
12381   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12382 *)
12383   ac_count=0
12384   $as_echo_n 0123456789 >"conftest.in"
12385   while :
12386   do
12387     cat "conftest.in" "conftest.in" >"conftest.tmp"
12388     mv "conftest.tmp" "conftest.in"
12389     cp "conftest.in" "conftest.nl"
12390     $as_echo '' >> "conftest.nl"
12391     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12392     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12393     as_fn_arith $ac_count + 1 && ac_count=$as_val
12394     if test $ac_count -gt ${ac_path_SED_max-0}; then
12395       # Best one so far, save it but keep looking for a better one
12396       ac_cv_path_SED="$ac_path_SED"
12397       ac_path_SED_max=$ac_count
12398     fi
12399     # 10*(2^10) chars as input seems more than enough
12400     test $ac_count -gt 10 && break
12401   done
12402   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12403 esac
12404 
12405       $ac_path_SED_found && break 3
12406     done
12407   done
12408   done
12409 IFS=$as_save_IFS
12410   if test -z "$ac_cv_path_SED"; then
12411     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12412   fi
12413 else
12414   ac_cv_path_SED=$SED
12415 fi
12416 
12417 fi
12418 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12419 $as_echo "$ac_cv_path_SED" >&6; }
12420  SED="$ac_cv_path_SED"
12421   rm -f conftest.sed
12422 
12423     else
12424       # If it succeeded, then it was overridden by the user. We will use it
12425       # for the tool.
12426 
12427       # First remove it from the list of overridden variables, so we can test
12428       # for unknown variables in the end.
12429       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12430 
12431       # Check if the provided tool contains a complete path.
12432       tool_specified="$SED"
12433       tool_basename="${tool_specified##*/}"
12434       if test "x$tool_basename" = "x$tool_specified"; then
12435         # A command without a complete path is provided, search $PATH.
12436         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
12437 $as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
12438         # Extract the first word of "$tool_basename", so it can be a program name with args.
12439 set dummy $tool_basename; ac_word=$2
12440 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12441 $as_echo_n "checking for $ac_word... " >&6; }
12442 if ${ac_cv_path_SED+:} false; then :
12443   $as_echo_n "(cached) " >&6
12444 else
12445   case $SED in
12446   [\\/]* | ?:[\\/]*)
12447   ac_cv_path_SED="$SED" # Let the user override the test with a path.
12448   ;;
12449   *)
12450   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12451 for as_dir in $PATH
12452 do
12453   IFS=$as_save_IFS
12454   test -z "$as_dir" && as_dir=.
12455     for ac_exec_ext in '' $ac_executable_extensions; do
12456   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12457     ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
12458     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12459     break 2
12460   fi
12461 done
12462   done
12463 IFS=$as_save_IFS
12464 
12465   ;;
12466 esac
12467 fi
12468 SED=$ac_cv_path_SED
12469 if test -n "$SED"; then
12470   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
12471 $as_echo "$SED" >&6; }
12472 else
12473   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12474 $as_echo "no" >&6; }
12475 fi
12476 
12477 
12478         if test "x$SED" = x; then
12479           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12480         fi
12481       else
12482         # Otherwise we believe it is a complete path. Use it as it is.
12483         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
12484 $as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
12485         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
12486 $as_echo_n "checking for SED... " >&6; }
12487         if test ! -x "$tool_specified"; then
12488           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12489 $as_echo "not found" >&6; }
12490           as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
12491         fi
12492         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12493 $as_echo "$tool_specified" >&6; }
12494       fi
12495     fi
12496   fi
12497 
12498 
12499   if test "x$SED" = x; then
12500     as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
12501   fi
12502 
12503 
12504 
12505   # Always force rm.
12506   RM="$RM -f"
12507 
12508   # pwd behaves differently on various platforms and some don't support the -L flag.
12509   # Always use the bash builtin pwd to get uniform behavior.
12510   THEPWDCMD=pwd
12511 
12512   # These are not required on all platforms
12513 
12514 
12515   # Publish this variable in the help.
12516 
12517 
12518   if test "x$CYGPATH" = x; then
12519     # The variable is not set by user, try to locate tool using the code snippet
12520     for ac_prog in cygpath
12521 do
12522   # Extract the first word of "$ac_prog", so it can be a program name with args.
12523 set dummy $ac_prog; ac_word=$2
12524 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12525 $as_echo_n "checking for $ac_word... " >&6; }
12526 if ${ac_cv_path_CYGPATH+:} false; then :
12527   $as_echo_n "(cached) " >&6
12528 else
12529   case $CYGPATH in
12530   [\\/]* | ?:[\\/]*)
12531   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12532   ;;
12533   *)
12534   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12535 for as_dir in $PATH
12536 do
12537   IFS=$as_save_IFS
12538   test -z "$as_dir" && as_dir=.
12539     for ac_exec_ext in '' $ac_executable_extensions; do
12540   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12541     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12542     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12543     break 2
12544   fi
12545 done
12546   done
12547 IFS=$as_save_IFS
12548 
12549   ;;
12550 esac
12551 fi
12552 CYGPATH=$ac_cv_path_CYGPATH
12553 if test -n "$CYGPATH"; then
12554   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12555 $as_echo "$CYGPATH" >&6; }
12556 else
12557   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12558 $as_echo "no" >&6; }
12559 fi
12560 
12561 
12562   test -n "$CYGPATH" && break
12563 done
12564 
12565   else
12566     # The variable is set, but is it from the command line or the environment?
12567 
12568     # Try to remove the string !CYGPATH! from our list.
12569     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
12570     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12571       # If it failed, the variable was not from the command line. Ignore it,
12572       # but warn the user (except for BASH, which is always set by the calling BASH).
12573       if test "xCYGPATH" != xBASH; then
12574         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
12575 $as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
12576       fi
12577       # Try to locate tool using the code snippet
12578       for ac_prog in cygpath
12579 do
12580   # Extract the first word of "$ac_prog", so it can be a program name with args.
12581 set dummy $ac_prog; ac_word=$2
12582 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12583 $as_echo_n "checking for $ac_word... " >&6; }
12584 if ${ac_cv_path_CYGPATH+:} false; then :
12585   $as_echo_n "(cached) " >&6
12586 else
12587   case $CYGPATH in
12588   [\\/]* | ?:[\\/]*)
12589   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12590   ;;
12591   *)
12592   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12593 for as_dir in $PATH
12594 do
12595   IFS=$as_save_IFS
12596   test -z "$as_dir" && as_dir=.
12597     for ac_exec_ext in '' $ac_executable_extensions; do
12598   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12599     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12600     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12601     break 2
12602   fi
12603 done
12604   done
12605 IFS=$as_save_IFS
12606 
12607   ;;
12608 esac
12609 fi
12610 CYGPATH=$ac_cv_path_CYGPATH
12611 if test -n "$CYGPATH"; then
12612   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12613 $as_echo "$CYGPATH" >&6; }
12614 else
12615   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12616 $as_echo "no" >&6; }
12617 fi
12618 
12619 
12620   test -n "$CYGPATH" && break
12621 done
12622 
12623     else
12624       # If it succeeded, then it was overridden by the user. We will use it
12625       # for the tool.
12626 
12627       # First remove it from the list of overridden variables, so we can test
12628       # for unknown variables in the end.
12629       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12630 
12631       # Check if the provided tool contains a complete path.
12632       tool_specified="$CYGPATH"
12633       tool_basename="${tool_specified##*/}"
12634       if test "x$tool_basename" = "x$tool_specified"; then
12635         # A command without a complete path is provided, search $PATH.
12636         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
12637 $as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
12638         # Extract the first word of "$tool_basename", so it can be a program name with args.
12639 set dummy $tool_basename; ac_word=$2
12640 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12641 $as_echo_n "checking for $ac_word... " >&6; }
12642 if ${ac_cv_path_CYGPATH+:} false; then :
12643   $as_echo_n "(cached) " >&6
12644 else
12645   case $CYGPATH in
12646   [\\/]* | ?:[\\/]*)
12647   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12648   ;;
12649   *)
12650   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12651 for as_dir in $PATH
12652 do
12653   IFS=$as_save_IFS
12654   test -z "$as_dir" && as_dir=.
12655     for ac_exec_ext in '' $ac_executable_extensions; do
12656   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12657     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12658     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12659     break 2
12660   fi
12661 done
12662   done
12663 IFS=$as_save_IFS
12664 
12665   ;;
12666 esac
12667 fi
12668 CYGPATH=$ac_cv_path_CYGPATH
12669 if test -n "$CYGPATH"; then
12670   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12671 $as_echo "$CYGPATH" >&6; }
12672 else
12673   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12674 $as_echo "no" >&6; }
12675 fi
12676 
12677 
12678         if test "x$CYGPATH" = x; then
12679           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12680         fi
12681       else
12682         # Otherwise we believe it is a complete path. Use it as it is.
12683         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
12684 $as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
12685         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
12686 $as_echo_n "checking for CYGPATH... " >&6; }
12687         if test ! -x "$tool_specified"; then
12688           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12689 $as_echo "not found" >&6; }
12690           as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
12691         fi
12692         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12693 $as_echo "$tool_specified" >&6; }
12694       fi
12695     fi
12696   fi
12697 
12698 
12699 
12700 
12701   # Publish this variable in the help.
12702 
12703 
12704   if test "x$READLINK" = x; then
12705     # The variable is not set by user, try to locate tool using the code snippet
12706     for ac_prog in greadlink readlink
12707 do
12708   # Extract the first word of "$ac_prog", so it can be a program name with args.
12709 set dummy $ac_prog; ac_word=$2
12710 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12711 $as_echo_n "checking for $ac_word... " >&6; }
12712 if ${ac_cv_path_READLINK+:} false; then :
12713   $as_echo_n "(cached) " >&6
12714 else
12715   case $READLINK in
12716   [\\/]* | ?:[\\/]*)
12717   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12718   ;;
12719   *)
12720   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12721 for as_dir in $PATH
12722 do
12723   IFS=$as_save_IFS
12724   test -z "$as_dir" && as_dir=.
12725     for ac_exec_ext in '' $ac_executable_extensions; do
12726   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12727     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12728     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12729     break 2
12730   fi
12731 done
12732   done
12733 IFS=$as_save_IFS
12734 
12735   ;;
12736 esac
12737 fi
12738 READLINK=$ac_cv_path_READLINK
12739 if test -n "$READLINK"; then
12740   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12741 $as_echo "$READLINK" >&6; }
12742 else
12743   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12744 $as_echo "no" >&6; }
12745 fi
12746 
12747 
12748   test -n "$READLINK" && break
12749 done
12750 
12751   else
12752     # The variable is set, but is it from the command line or the environment?
12753 
12754     # Try to remove the string !READLINK! from our list.
12755     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
12756     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12757       # If it failed, the variable was not from the command line. Ignore it,
12758       # but warn the user (except for BASH, which is always set by the calling BASH).
12759       if test "xREADLINK" != xBASH; then
12760         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
12761 $as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
12762       fi
12763       # Try to locate tool using the code snippet
12764       for ac_prog in greadlink readlink
12765 do
12766   # Extract the first word of "$ac_prog", so it can be a program name with args.
12767 set dummy $ac_prog; ac_word=$2
12768 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12769 $as_echo_n "checking for $ac_word... " >&6; }
12770 if ${ac_cv_path_READLINK+:} false; then :
12771   $as_echo_n "(cached) " >&6
12772 else
12773   case $READLINK in
12774   [\\/]* | ?:[\\/]*)
12775   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12776   ;;
12777   *)
12778   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12779 for as_dir in $PATH
12780 do
12781   IFS=$as_save_IFS
12782   test -z "$as_dir" && as_dir=.
12783     for ac_exec_ext in '' $ac_executable_extensions; do
12784   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12785     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12786     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12787     break 2
12788   fi
12789 done
12790   done
12791 IFS=$as_save_IFS
12792 
12793   ;;
12794 esac
12795 fi
12796 READLINK=$ac_cv_path_READLINK
12797 if test -n "$READLINK"; then
12798   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12799 $as_echo "$READLINK" >&6; }
12800 else
12801   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12802 $as_echo "no" >&6; }
12803 fi
12804 
12805 
12806   test -n "$READLINK" && break
12807 done
12808 
12809     else
12810       # If it succeeded, then it was overridden by the user. We will use it
12811       # for the tool.
12812 
12813       # First remove it from the list of overridden variables, so we can test
12814       # for unknown variables in the end.
12815       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12816 
12817       # Check if the provided tool contains a complete path.
12818       tool_specified="$READLINK"
12819       tool_basename="${tool_specified##*/}"
12820       if test "x$tool_basename" = "x$tool_specified"; then
12821         # A command without a complete path is provided, search $PATH.
12822         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
12823 $as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
12824         # Extract the first word of "$tool_basename", so it can be a program name with args.
12825 set dummy $tool_basename; ac_word=$2
12826 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12827 $as_echo_n "checking for $ac_word... " >&6; }
12828 if ${ac_cv_path_READLINK+:} false; then :
12829   $as_echo_n "(cached) " >&6
12830 else
12831   case $READLINK in
12832   [\\/]* | ?:[\\/]*)
12833   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12834   ;;
12835   *)
12836   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12837 for as_dir in $PATH
12838 do
12839   IFS=$as_save_IFS
12840   test -z "$as_dir" && as_dir=.
12841     for ac_exec_ext in '' $ac_executable_extensions; do
12842   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12843     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12844     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12845     break 2
12846   fi
12847 done
12848   done
12849 IFS=$as_save_IFS
12850 
12851   ;;
12852 esac
12853 fi
12854 READLINK=$ac_cv_path_READLINK
12855 if test -n "$READLINK"; then
12856   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12857 $as_echo "$READLINK" >&6; }
12858 else
12859   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12860 $as_echo "no" >&6; }
12861 fi
12862 
12863 
12864         if test "x$READLINK" = x; then
12865           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12866         fi
12867       else
12868         # Otherwise we believe it is a complete path. Use it as it is.
12869         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
12870 $as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
12871         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
12872 $as_echo_n "checking for READLINK... " >&6; }
12873         if test ! -x "$tool_specified"; then
12874           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12875 $as_echo "not found" >&6; }
12876           as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
12877         fi
12878         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12879 $as_echo "$tool_specified" >&6; }
12880       fi
12881     fi
12882   fi
12883 
12884 
12885 
12886 
12887   # Publish this variable in the help.
12888 
12889 
12890   if test "x$DF" = x; then
12891     # The variable is not set by user, try to locate tool using the code snippet
12892     for ac_prog in df
12893 do
12894   # Extract the first word of "$ac_prog", so it can be a program name with args.
12895 set dummy $ac_prog; ac_word=$2
12896 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12897 $as_echo_n "checking for $ac_word... " >&6; }
12898 if ${ac_cv_path_DF+:} false; then :
12899   $as_echo_n "(cached) " >&6
12900 else
12901   case $DF in
12902   [\\/]* | ?:[\\/]*)
12903   ac_cv_path_DF="$DF" # Let the user override the test with a path.
12904   ;;
12905   *)
12906   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12907 for as_dir in $PATH
12908 do
12909   IFS=$as_save_IFS
12910   test -z "$as_dir" && as_dir=.
12911     for ac_exec_ext in '' $ac_executable_extensions; do
12912   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12913     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12914     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12915     break 2
12916   fi
12917 done
12918   done
12919 IFS=$as_save_IFS
12920 
12921   ;;
12922 esac
12923 fi
12924 DF=$ac_cv_path_DF
12925 if test -n "$DF"; then
12926   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12927 $as_echo "$DF" >&6; }
12928 else
12929   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12930 $as_echo "no" >&6; }
12931 fi
12932 
12933 
12934   test -n "$DF" && break
12935 done
12936 
12937   else
12938     # The variable is set, but is it from the command line or the environment?
12939 
12940     # Try to remove the string !DF! from our list.
12941     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
12942     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12943       # If it failed, the variable was not from the command line. Ignore it,
12944       # but warn the user (except for BASH, which is always set by the calling BASH).
12945       if test "xDF" != xBASH; then
12946         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
12947 $as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
12948       fi
12949       # Try to locate tool using the code snippet
12950       for ac_prog in df
12951 do
12952   # Extract the first word of "$ac_prog", so it can be a program name with args.
12953 set dummy $ac_prog; ac_word=$2
12954 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12955 $as_echo_n "checking for $ac_word... " >&6; }
12956 if ${ac_cv_path_DF+:} false; then :
12957   $as_echo_n "(cached) " >&6
12958 else
12959   case $DF in
12960   [\\/]* | ?:[\\/]*)
12961   ac_cv_path_DF="$DF" # Let the user override the test with a path.
12962   ;;
12963   *)
12964   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12965 for as_dir in $PATH
12966 do
12967   IFS=$as_save_IFS
12968   test -z "$as_dir" && as_dir=.
12969     for ac_exec_ext in '' $ac_executable_extensions; do
12970   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12971     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12972     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12973     break 2
12974   fi
12975 done
12976   done
12977 IFS=$as_save_IFS
12978 
12979   ;;
12980 esac
12981 fi
12982 DF=$ac_cv_path_DF
12983 if test -n "$DF"; then
12984   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12985 $as_echo "$DF" >&6; }
12986 else
12987   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12988 $as_echo "no" >&6; }
12989 fi
12990 
12991 
12992   test -n "$DF" && break
12993 done
12994 
12995     else
12996       # If it succeeded, then it was overridden by the user. We will use it
12997       # for the tool.
12998 
12999       # First remove it from the list of overridden variables, so we can test
13000       # for unknown variables in the end.
13001       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13002 
13003       # Check if the provided tool contains a complete path.
13004       tool_specified="$DF"
13005       tool_basename="${tool_specified##*/}"
13006       if test "x$tool_basename" = "x$tool_specified"; then
13007         # A command without a complete path is provided, search $PATH.
13008         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
13009 $as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
13010         # Extract the first word of "$tool_basename", so it can be a program name with args.
13011 set dummy $tool_basename; ac_word=$2
13012 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13013 $as_echo_n "checking for $ac_word... " >&6; }
13014 if ${ac_cv_path_DF+:} false; then :
13015   $as_echo_n "(cached) " >&6
13016 else
13017   case $DF in
13018   [\\/]* | ?:[\\/]*)
13019   ac_cv_path_DF="$DF" # Let the user override the test with a path.
13020   ;;
13021   *)
13022   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13023 for as_dir in $PATH
13024 do
13025   IFS=$as_save_IFS
13026   test -z "$as_dir" && as_dir=.
13027     for ac_exec_ext in '' $ac_executable_extensions; do
13028   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13029     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
13030     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13031     break 2
13032   fi
13033 done
13034   done
13035 IFS=$as_save_IFS
13036 
13037   ;;
13038 esac
13039 fi
13040 DF=$ac_cv_path_DF
13041 if test -n "$DF"; then
13042   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
13043 $as_echo "$DF" >&6; }
13044 else
13045   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13046 $as_echo "no" >&6; }
13047 fi
13048 
13049 
13050         if test "x$DF" = x; then
13051           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13052         fi
13053       else
13054         # Otherwise we believe it is a complete path. Use it as it is.
13055         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
13056 $as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
13057         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
13058 $as_echo_n "checking for DF... " >&6; }
13059         if test ! -x "$tool_specified"; then
13060           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13061 $as_echo "not found" >&6; }
13062           as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
13063         fi
13064         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13065 $as_echo "$tool_specified" >&6; }
13066       fi
13067     fi
13068   fi
13069 
13070 
13071 
13072 
13073   # Publish this variable in the help.
13074 
13075 
13076   if test "x$SETFILE" = x; then
13077     # The variable is not set by user, try to locate tool using the code snippet
13078     for ac_prog in SetFile
13079 do
13080   # Extract the first word of "$ac_prog", so it can be a program name with args.
13081 set dummy $ac_prog; ac_word=$2
13082 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13083 $as_echo_n "checking for $ac_word... " >&6; }
13084 if ${ac_cv_path_SETFILE+:} false; then :
13085   $as_echo_n "(cached) " >&6
13086 else
13087   case $SETFILE in
13088   [\\/]* | ?:[\\/]*)
13089   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13090   ;;
13091   *)
13092   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13093 for as_dir in $PATH
13094 do
13095   IFS=$as_save_IFS
13096   test -z "$as_dir" && as_dir=.
13097     for ac_exec_ext in '' $ac_executable_extensions; do
13098   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13099     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13100     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13101     break 2
13102   fi
13103 done
13104   done
13105 IFS=$as_save_IFS
13106 
13107   ;;
13108 esac
13109 fi
13110 SETFILE=$ac_cv_path_SETFILE
13111 if test -n "$SETFILE"; then
13112   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13113 $as_echo "$SETFILE" >&6; }
13114 else
13115   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13116 $as_echo "no" >&6; }
13117 fi
13118 
13119 
13120   test -n "$SETFILE" && break
13121 done
13122 
13123   else
13124     # The variable is set, but is it from the command line or the environment?
13125 
13126     # Try to remove the string !SETFILE! from our list.
13127     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
13128     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13129       # If it failed, the variable was not from the command line. Ignore it,
13130       # but warn the user (except for BASH, which is always set by the calling BASH).
13131       if test "xSETFILE" != xBASH; then
13132         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
13133 $as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
13134       fi
13135       # Try to locate tool using the code snippet
13136       for ac_prog in SetFile
13137 do
13138   # Extract the first word of "$ac_prog", so it can be a program name with args.
13139 set dummy $ac_prog; ac_word=$2
13140 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13141 $as_echo_n "checking for $ac_word... " >&6; }
13142 if ${ac_cv_path_SETFILE+:} false; then :
13143   $as_echo_n "(cached) " >&6
13144 else
13145   case $SETFILE in
13146   [\\/]* | ?:[\\/]*)
13147   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13148   ;;
13149   *)
13150   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13151 for as_dir in $PATH
13152 do
13153   IFS=$as_save_IFS
13154   test -z "$as_dir" && as_dir=.
13155     for ac_exec_ext in '' $ac_executable_extensions; do
13156   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13157     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13158     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13159     break 2
13160   fi
13161 done
13162   done
13163 IFS=$as_save_IFS
13164 
13165   ;;
13166 esac
13167 fi
13168 SETFILE=$ac_cv_path_SETFILE
13169 if test -n "$SETFILE"; then
13170   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13171 $as_echo "$SETFILE" >&6; }
13172 else
13173   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13174 $as_echo "no" >&6; }
13175 fi
13176 
13177 
13178   test -n "$SETFILE" && break
13179 done
13180 
13181     else
13182       # If it succeeded, then it was overridden by the user. We will use it
13183       # for the tool.
13184 
13185       # First remove it from the list of overridden variables, so we can test
13186       # for unknown variables in the end.
13187       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13188 
13189       # Check if the provided tool contains a complete path.
13190       tool_specified="$SETFILE"
13191       tool_basename="${tool_specified##*/}"
13192       if test "x$tool_basename" = "x$tool_specified"; then
13193         # A command without a complete path is provided, search $PATH.
13194         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
13195 $as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
13196         # Extract the first word of "$tool_basename", so it can be a program name with args.
13197 set dummy $tool_basename; ac_word=$2
13198 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13199 $as_echo_n "checking for $ac_word... " >&6; }
13200 if ${ac_cv_path_SETFILE+:} false; then :
13201   $as_echo_n "(cached) " >&6
13202 else
13203   case $SETFILE in
13204   [\\/]* | ?:[\\/]*)
13205   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13206   ;;
13207   *)
13208   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13209 for as_dir in $PATH
13210 do
13211   IFS=$as_save_IFS
13212   test -z "$as_dir" && as_dir=.
13213     for ac_exec_ext in '' $ac_executable_extensions; do
13214   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13215     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13216     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13217     break 2
13218   fi
13219 done
13220   done
13221 IFS=$as_save_IFS
13222 
13223   ;;
13224 esac
13225 fi
13226 SETFILE=$ac_cv_path_SETFILE
13227 if test -n "$SETFILE"; then
13228   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13229 $as_echo "$SETFILE" >&6; }
13230 else
13231   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13232 $as_echo "no" >&6; }
13233 fi
13234 
13235 
13236         if test "x$SETFILE" = x; then
13237           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13238         fi
13239       else
13240         # Otherwise we believe it is a complete path. Use it as it is.
13241         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
13242 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
13243         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
13244 $as_echo_n "checking for SETFILE... " >&6; }
13245         if test ! -x "$tool_specified"; then
13246           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13247 $as_echo "not found" >&6; }
13248           as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
13249         fi
13250         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13251 $as_echo "$tool_specified" >&6; }
13252       fi
13253     fi
13254   fi
13255 
13256 
13257 
13258 
13259   # Publish this variable in the help.
13260 
13261 
13262   if test "x$CPIO" = x; then
13263     # The variable is not set by user, try to locate tool using the code snippet
13264     for ac_prog in cpio bsdcpio
13265 do
13266   # Extract the first word of "$ac_prog", so it can be a program name with args.
13267 set dummy $ac_prog; ac_word=$2
13268 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13269 $as_echo_n "checking for $ac_word... " >&6; }
13270 if ${ac_cv_path_CPIO+:} false; then :
13271   $as_echo_n "(cached) " >&6
13272 else
13273   case $CPIO in
13274   [\\/]* | ?:[\\/]*)
13275   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13276   ;;
13277   *)
13278   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13279 for as_dir in $PATH
13280 do
13281   IFS=$as_save_IFS
13282   test -z "$as_dir" && as_dir=.
13283     for ac_exec_ext in '' $ac_executable_extensions; do
13284   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13285     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13286     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13287     break 2
13288   fi
13289 done
13290   done
13291 IFS=$as_save_IFS
13292 
13293   ;;
13294 esac
13295 fi
13296 CPIO=$ac_cv_path_CPIO
13297 if test -n "$CPIO"; then
13298   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13299 $as_echo "$CPIO" >&6; }
13300 else
13301   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13302 $as_echo "no" >&6; }
13303 fi
13304 
13305 
13306   test -n "$CPIO" && break
13307 done
13308 
13309   else
13310     # The variable is set, but is it from the command line or the environment?
13311 
13312     # Try to remove the string !CPIO! from our list.
13313     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
13314     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13315       # If it failed, the variable was not from the command line. Ignore it,
13316       # but warn the user (except for BASH, which is always set by the calling BASH).
13317       if test "xCPIO" != xBASH; then
13318         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
13319 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
13320       fi
13321       # Try to locate tool using the code snippet
13322       for ac_prog in cpio bsdcpio
13323 do
13324   # Extract the first word of "$ac_prog", so it can be a program name with args.
13325 set dummy $ac_prog; ac_word=$2
13326 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13327 $as_echo_n "checking for $ac_word... " >&6; }
13328 if ${ac_cv_path_CPIO+:} false; then :
13329   $as_echo_n "(cached) " >&6
13330 else
13331   case $CPIO in
13332   [\\/]* | ?:[\\/]*)
13333   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13334   ;;
13335   *)
13336   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13337 for as_dir in $PATH
13338 do
13339   IFS=$as_save_IFS
13340   test -z "$as_dir" && as_dir=.
13341     for ac_exec_ext in '' $ac_executable_extensions; do
13342   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13343     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13344     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13345     break 2
13346   fi
13347 done
13348   done
13349 IFS=$as_save_IFS
13350 
13351   ;;
13352 esac
13353 fi
13354 CPIO=$ac_cv_path_CPIO
13355 if test -n "$CPIO"; then
13356   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13357 $as_echo "$CPIO" >&6; }
13358 else
13359   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13360 $as_echo "no" >&6; }
13361 fi
13362 
13363 
13364   test -n "$CPIO" && break
13365 done
13366 
13367     else
13368       # If it succeeded, then it was overridden by the user. We will use it
13369       # for the tool.
13370 
13371       # First remove it from the list of overridden variables, so we can test
13372       # for unknown variables in the end.
13373       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13374 
13375       # Check if the provided tool contains a complete path.
13376       tool_specified="$CPIO"
13377       tool_basename="${tool_specified##*/}"
13378       if test "x$tool_basename" = "x$tool_specified"; then
13379         # A command without a complete path is provided, search $PATH.
13380         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
13381 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
13382         # Extract the first word of "$tool_basename", so it can be a program name with args.
13383 set dummy $tool_basename; ac_word=$2
13384 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13385 $as_echo_n "checking for $ac_word... " >&6; }
13386 if ${ac_cv_path_CPIO+:} false; then :
13387   $as_echo_n "(cached) " >&6
13388 else
13389   case $CPIO in
13390   [\\/]* | ?:[\\/]*)
13391   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13392   ;;
13393   *)
13394   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13395 for as_dir in $PATH
13396 do
13397   IFS=$as_save_IFS
13398   test -z "$as_dir" && as_dir=.
13399     for ac_exec_ext in '' $ac_executable_extensions; do
13400   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13401     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13402     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13403     break 2
13404   fi
13405 done
13406   done
13407 IFS=$as_save_IFS
13408 
13409   ;;
13410 esac
13411 fi
13412 CPIO=$ac_cv_path_CPIO
13413 if test -n "$CPIO"; then
13414   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13415 $as_echo "$CPIO" >&6; }
13416 else
13417   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13418 $as_echo "no" >&6; }
13419 fi
13420 
13421 
13422         if test "x$CPIO" = x; then
13423           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13424         fi
13425       else
13426         # Otherwise we believe it is a complete path. Use it as it is.
13427         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
13428 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
13429         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
13430 $as_echo_n "checking for CPIO... " >&6; }
13431         if test ! -x "$tool_specified"; then
13432           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13433 $as_echo "not found" >&6; }
13434           as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
13435         fi
13436         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13437 $as_echo "$tool_specified" >&6; }
13438       fi
13439     fi
13440   fi
13441 
13442 
13443 
13444 
13445 # Now we can determine OpenJDK build and target platforms. This is required to
13446 # have early on.
13447 # Make sure we can run config.sub.
13448 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
13449   as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
13450 
13451 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
13452 $as_echo_n "checking build system type... " >&6; }
13453 if ${ac_cv_build+:} false; then :
13454   $as_echo_n "(cached) " >&6
13455 else
13456   ac_build_alias=$build_alias
13457 test "x$ac_build_alias" = x &&
13458   ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
13459 test "x$ac_build_alias" = x &&
13460   as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
13461 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
13462   as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
13463 
13464 fi
13465 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
13466 $as_echo "$ac_cv_build" >&6; }
13467 case $ac_cv_build in
13468 *-*-*) ;;
13469 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
13470 esac
13471 build=$ac_cv_build
13472 ac_save_IFS=$IFS; IFS='-'
13473 set x $ac_cv_build
13474 shift
13475 build_cpu=$1
13476 build_vendor=$2
13477 shift; shift
13478 # Remember, the first character of IFS is used to create $*,
13479 # except with old shells:
13480 build_os=$*
13481 IFS=$ac_save_IFS
13482 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
13483 
13484 
13485 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
13486 $as_echo_n "checking host system type... " >&6; }
13487 if ${ac_cv_host+:} false; then :
13488   $as_echo_n "(cached) " >&6
13489 else
13490   if test "x$host_alias" = x; then
13491   ac_cv_host=$ac_cv_build
13492 else
13493   ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
13494     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
13495 fi
13496 
13497 fi
13498 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
13499 $as_echo "$ac_cv_host" >&6; }
13500 case $ac_cv_host in
13501 *-*-*) ;;
13502 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
13503 esac
13504 host=$ac_cv_host
13505 ac_save_IFS=$IFS; IFS='-'
13506 set x $ac_cv_host
13507 shift
13508 host_cpu=$1
13509 host_vendor=$2
13510 shift; shift
13511 # Remember, the first character of IFS is used to create $*,
13512 # except with old shells:
13513 host_os=$*
13514 IFS=$ac_save_IFS
13515 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
13516 
13517 
13518 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
13519 $as_echo_n "checking target system type... " >&6; }
13520 if ${ac_cv_target+:} false; then :
13521   $as_echo_n "(cached) " >&6
13522 else
13523   if test "x$target_alias" = x; then
13524   ac_cv_target=$ac_cv_host
13525 else
13526   ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
13527     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
13528 fi
13529 
13530 fi
13531 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
13532 $as_echo "$ac_cv_target" >&6; }
13533 case $ac_cv_target in
13534 *-*-*) ;;
13535 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
13536 esac
13537 target=$ac_cv_target
13538 ac_save_IFS=$IFS; IFS='-'
13539 set x $ac_cv_target
13540 shift
13541 target_cpu=$1
13542 target_vendor=$2
13543 shift; shift
13544 # Remember, the first character of IFS is used to create $*,
13545 # except with old shells:
13546 target_os=$*
13547 IFS=$ac_save_IFS
13548 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
13549 
13550 
13551 # The aliases save the names the user supplied, while $host etc.
13552 # will get canonicalized.
13553 test -n "$target_alias" &&
13554   test "$program_prefix$program_suffix$program_transform_name" = \
13555     NONENONEs,x,x, &&
13556   program_prefix=${target_alias}-
13557 
13558   # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
13559   # is confusing; it assumes you are cross-compiling a cross-compiler (!)  and "target" is thus the target of the
13560   # product you're building. The target of this build is called "host". Since this is confusing to most people, we
13561   # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
13562   # to use the configure naming style.
13563 
13564 
13565 
13566 
13567 
13568   # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
13569   # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
13570   # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
13571   # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
13572   OPENJDK_TARGET_AUTOCONF_NAME="$host"
13573   OPENJDK_BUILD_AUTOCONF_NAME="$build"
13574 
13575 
13576 
13577   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13578 
13579   case "$build_os" in
13580     *linux*)
13581       VAR_OS=linux
13582       VAR_OS_API=posix
13583       VAR_OS_ENV=linux
13584       ;;
13585     *solaris*)
13586       VAR_OS=solaris
13587       VAR_OS_API=posix
13588       VAR_OS_ENV=solaris
13589       ;;
13590     *darwin*)
13591       VAR_OS=macosx
13592       VAR_OS_API=posix
13593       VAR_OS_ENV=macosx
13594       ;;
13595     *bsd*)
13596       VAR_OS=bsd
13597       VAR_OS_API=posix
13598       VAR_OS_ENV=bsd
13599       ;;
13600     *cygwin*)
13601       VAR_OS=windows
13602       VAR_OS_API=winapi
13603       VAR_OS_ENV=windows.cygwin
13604       ;;
13605     *mingw*)
13606       VAR_OS=windows
13607       VAR_OS_API=winapi
13608       VAR_OS_ENV=windows.msys
13609       ;;
13610     *aix*)
13611       VAR_OS=aix
13612       VAR_OS_API=posix
13613       VAR_OS_ENV=aix
13614       ;;
13615     *)
13616       as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
13617       ;;
13618   esac
13619 
13620 
13621   # First argument is the cpu name from the trip/quad
13622   case "$build_cpu" in
13623     x86_64)
13624       VAR_CPU=x86_64
13625       VAR_CPU_ARCH=x86
13626       VAR_CPU_BITS=64
13627       VAR_CPU_ENDIAN=little
13628       ;;
13629     i?86)
13630       VAR_CPU=x86
13631       VAR_CPU_ARCH=x86
13632       VAR_CPU_BITS=32
13633       VAR_CPU_ENDIAN=little
13634       ;;
13635     arm*)
13636       VAR_CPU=arm
13637       VAR_CPU_ARCH=arm
13638       VAR_CPU_BITS=32
13639       VAR_CPU_ENDIAN=little
13640       ;;
13641     aarch64)
13642       VAR_CPU=aarch64
13643       VAR_CPU_ARCH=aarch64
13644       VAR_CPU_BITS=64
13645       VAR_CPU_ENDIAN=little
13646       ;;
13647     powerpc)
13648       VAR_CPU=ppc
13649       VAR_CPU_ARCH=ppc
13650       VAR_CPU_BITS=32
13651       VAR_CPU_ENDIAN=big
13652       ;;
13653     powerpc64)
13654       VAR_CPU=ppc64
13655       VAR_CPU_ARCH=ppc
13656       VAR_CPU_BITS=64
13657       VAR_CPU_ENDIAN=big
13658       ;;
13659     powerpc64le)
13660       VAR_CPU=ppc64le
13661       VAR_CPU_ARCH=ppc
13662       VAR_CPU_BITS=64
13663       VAR_CPU_ENDIAN=little
13664       ;;
13665     s390)
13666       VAR_CPU=s390
13667       VAR_CPU_ARCH=s390
13668       VAR_CPU_BITS=32
13669       VAR_CPU_ENDIAN=big
13670       ;;
13671     s390x)
13672       VAR_CPU=s390x
13673       VAR_CPU_ARCH=s390
13674       VAR_CPU_BITS=64
13675       VAR_CPU_ENDIAN=big
13676       ;;
13677     sparc)
13678       VAR_CPU=sparc
13679       VAR_CPU_ARCH=sparc
13680       VAR_CPU_BITS=32
13681       VAR_CPU_ENDIAN=big
13682       ;;
13683     sparcv9|sparc64)
13684       VAR_CPU=sparcv9
13685       VAR_CPU_ARCH=sparc
13686       VAR_CPU_BITS=64
13687       VAR_CPU_ENDIAN=big
13688       ;;
13689     *)
13690       as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
13691       ;;
13692   esac
13693 
13694   # ..and setup our own variables. (Do this explicitely to facilitate searching)
13695   OPENJDK_BUILD_OS="$VAR_OS"
13696   OPENJDK_BUILD_OS_API="$VAR_OS_API"
13697   OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
13698   OPENJDK_BUILD_CPU="$VAR_CPU"
13699   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
13700   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
13701   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13702 
13703 
13704 
13705 
13706 
13707 
13708 
13709 
13710   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
13711 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
13712   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
13713 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
13714 
13715   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13716 
13717   case "$host_os" in
13718     *linux*)
13719       VAR_OS=linux
13720       VAR_OS_API=posix
13721       VAR_OS_ENV=linux
13722       ;;
13723     *solaris*)
13724       VAR_OS=solaris
13725       VAR_OS_API=posix
13726       VAR_OS_ENV=solaris
13727       ;;
13728     *darwin*)
13729       VAR_OS=macosx
13730       VAR_OS_API=posix
13731       VAR_OS_ENV=macosx
13732       ;;
13733     *bsd*)
13734       VAR_OS=bsd
13735       VAR_OS_API=posix
13736       VAR_OS_ENV=bsd
13737       ;;
13738     *cygwin*)
13739       VAR_OS=windows
13740       VAR_OS_API=winapi
13741       VAR_OS_ENV=windows.cygwin
13742       ;;
13743     *mingw*)
13744       VAR_OS=windows
13745       VAR_OS_API=winapi
13746       VAR_OS_ENV=windows.msys
13747       ;;
13748     *aix*)
13749       VAR_OS=aix
13750       VAR_OS_API=posix
13751       VAR_OS_ENV=aix
13752       ;;
13753     *)
13754       as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
13755       ;;
13756   esac
13757 
13758 
13759   # First argument is the cpu name from the trip/quad
13760   case "$host_cpu" in
13761     x86_64)
13762       VAR_CPU=x86_64
13763       VAR_CPU_ARCH=x86
13764       VAR_CPU_BITS=64
13765       VAR_CPU_ENDIAN=little
13766       ;;
13767     i?86)
13768       VAR_CPU=x86
13769       VAR_CPU_ARCH=x86
13770       VAR_CPU_BITS=32
13771       VAR_CPU_ENDIAN=little
13772       ;;
13773     arm*)
13774       VAR_CPU=arm
13775       VAR_CPU_ARCH=arm
13776       VAR_CPU_BITS=32
13777       VAR_CPU_ENDIAN=little
13778       ;;
13779     aarch64)
13780       VAR_CPU=aarch64
13781       VAR_CPU_ARCH=aarch64
13782       VAR_CPU_BITS=64
13783       VAR_CPU_ENDIAN=little
13784       ;;
13785     powerpc)
13786       VAR_CPU=ppc
13787       VAR_CPU_ARCH=ppc
13788       VAR_CPU_BITS=32
13789       VAR_CPU_ENDIAN=big
13790       ;;
13791     powerpc64)
13792       VAR_CPU=ppc64
13793       VAR_CPU_ARCH=ppc
13794       VAR_CPU_BITS=64
13795       VAR_CPU_ENDIAN=big
13796       ;;
13797     powerpc64le)
13798       VAR_CPU=ppc64le
13799       VAR_CPU_ARCH=ppc
13800       VAR_CPU_BITS=64
13801       VAR_CPU_ENDIAN=little
13802       ;;
13803     s390)
13804       VAR_CPU=s390
13805       VAR_CPU_ARCH=s390
13806       VAR_CPU_BITS=32
13807       VAR_CPU_ENDIAN=big
13808       ;;
13809     s390x)
13810       VAR_CPU=s390x
13811       VAR_CPU_ARCH=s390
13812       VAR_CPU_BITS=64
13813       VAR_CPU_ENDIAN=big
13814       ;;
13815     sparc)
13816       VAR_CPU=sparc
13817       VAR_CPU_ARCH=sparc
13818       VAR_CPU_BITS=32
13819       VAR_CPU_ENDIAN=big
13820       ;;
13821     sparcv9|sparc64)
13822       VAR_CPU=sparcv9
13823       VAR_CPU_ARCH=sparc
13824       VAR_CPU_BITS=64
13825       VAR_CPU_ENDIAN=big
13826       ;;
13827     *)
13828       as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
13829       ;;
13830   esac
13831 
13832   # ... and setup our own variables. (Do this explicitely to facilitate searching)
13833   OPENJDK_TARGET_OS="$VAR_OS"
13834   OPENJDK_TARGET_OS_API="$VAR_OS_API"
13835   OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
13836   OPENJDK_TARGET_CPU="$VAR_CPU"
13837   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
13838   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
13839   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13840 
13841 
13842 
13843 
13844 
13845 
13846 
13847 
13848   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
13849 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
13850   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
13851 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
13852 
13853 
13854 
13855 # Check whether --with-target-bits was given.
13856 if test "${with_target_bits+set}" = set; then :
13857   withval=$with_target_bits;
13858 fi
13859 
13860 
13861   # We have three types of compiles:
13862   # native  == normal compilation, target system == build system
13863   # cross   == traditional cross compilation, target system != build system; special toolchain needed
13864   # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
13865   #
13866   if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
13867     # We're doing a proper cross-compilation
13868     COMPILE_TYPE="cross"
13869   else
13870     COMPILE_TYPE="native"
13871   fi
13872 
13873   if test "x$with_target_bits" != x; then
13874     if test "x$COMPILE_TYPE" = "xcross"; then
13875       as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
13876     fi
13877 
13878     if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13879       # A reduced build is requested
13880       COMPILE_TYPE="reduced"
13881       OPENJDK_TARGET_CPU_BITS=32
13882       if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
13883         OPENJDK_TARGET_CPU=x86
13884       elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
13885         OPENJDK_TARGET_CPU=sparc
13886       else
13887         as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
13888       fi
13889     elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
13890       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
13891     elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
13892       { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
13893 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
13894     else
13895       as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
13896     fi
13897   fi
13898 
13899 
13900   { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
13901 $as_echo_n "checking compilation type... " >&6; }
13902   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
13903 $as_echo "$COMPILE_TYPE" >&6; }
13904 
13905 
13906   if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
13907     REQUIRED_OS_NAME=SunOS
13908     REQUIRED_OS_VERSION=5.10
13909   fi
13910   if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
13911     REQUIRED_OS_NAME=Linux
13912     REQUIRED_OS_VERSION=2.6
13913   fi
13914   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
13915     REQUIRED_OS_NAME=Windows
13916     if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
13917       REQUIRED_OS_VERSION=5.2
13918     else
13919       REQUIRED_OS_VERSION=5.1
13920     fi
13921   fi
13922   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
13923     REQUIRED_OS_NAME=Darwin
13924     REQUIRED_OS_VERSION=11.2
13925   fi
13926 
13927 
13928 
13929 
13930 
13931   # Also store the legacy naming of the cpu.
13932   # Ie i586 and amd64 instead of x86 and x86_64
13933   OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
13934   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13935     OPENJDK_TARGET_CPU_LEGACY="i586"
13936   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13937     # On all platforms except MacOSX replace x86_64 with amd64.
13938     OPENJDK_TARGET_CPU_LEGACY="amd64"
13939   fi
13940 
13941 
13942   # And the second legacy naming of the cpu.
13943   # Ie i386 and amd64 instead of x86 and x86_64.
13944   OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
13945   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13946     OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
13947   elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13948     OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
13949   fi
13950 
13951 
13952   # This is the name of the cpu (but using i386 and amd64 instead of
13953   # x86 and x86_64, respectively), preceeded by a /, to be used when
13954   # locating libraries. On macosx, it's empty, though.
13955   OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
13956   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13957     OPENJDK_TARGET_CPU_LIBDIR=""
13958   fi
13959 
13960 
13961   # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
13962   # /amd64 or /sparcv9. This string is appended to some library paths, like this:
13963   # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
13964   OPENJDK_TARGET_CPU_ISADIR=""
13965   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13966     if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13967       OPENJDK_TARGET_CPU_ISADIR="/amd64"
13968     elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
13969       OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
13970     fi
13971   fi
13972 
13973 
13974   # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
13975   OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
13976   if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
13977     # On linux only, we replace x86 with i386.
13978     OPENJDK_TARGET_CPU_OSARCH="i386"
13979   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13980     # On all platforms except macosx, we replace x86_64 with amd64.
13981     OPENJDK_TARGET_CPU_OSARCH="amd64"
13982   fi
13983 
13984 
13985   OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
13986   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13987     OPENJDK_TARGET_CPU_JLI="i386"
13988   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13989     # On all platforms except macosx, we replace x86_64 with amd64.
13990     OPENJDK_TARGET_CPU_JLI="amd64"
13991   fi
13992   # Now setup the -D flags for building libjli.
13993   OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
13994   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13995     if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
13996       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
13997     elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
13998       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
13999     fi
14000   fi
14001 
14002 
14003   # Setup OPENJDK_TARGET_OS_API_DIR, used in source paths.
14004   if test "x$OPENJDK_TARGET_OS_API" = xposix; then
14005     OPENJDK_TARGET_OS_API_DIR="solaris"
14006   fi
14007   if test "x$OPENJDK_TARGET_OS_API" = xwinapi; then
14008     OPENJDK_TARGET_OS_API_DIR="windows"
14009   fi
14010 
14011 
14012   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
14013       OPENJDK_TARGET_OS_EXPORT_DIR=macosx
14014   else
14015       OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_API_DIR}
14016   fi
14017 
14018 
14019   if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14020     A_LP64="LP64:="
14021     # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
14022     # unpack200.exe
14023     if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
14024       ADD_LP64="-D_LP64=1"
14025     fi
14026   fi
14027   LP64=$A_LP64
14028 
14029 
14030   if test "x$COMPILE_TYPE" = "xcross"; then
14031     # FIXME: ... or should this include reduced builds..?
14032     DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
14033   else
14034     DEFINE_CROSS_COMPILE_ARCH=""
14035   fi
14036 
14037 
14038   # ZERO_ARCHDEF is used to enable architecture-specific code
14039   case "${OPENJDK_TARGET_CPU}" in
14040     ppc)     ZERO_ARCHDEF=PPC32 ;;
14041     ppc64)   ZERO_ARCHDEF=PPC64 ;;
14042     s390*)   ZERO_ARCHDEF=S390  ;;
14043     sparc*)  ZERO_ARCHDEF=SPARC ;;
14044     x86_64*) ZERO_ARCHDEF=AMD64 ;;
14045     x86)     ZERO_ARCHDEF=IA32  ;;
14046     *)      ZERO_ARCHDEF=$(echo "${OPENJDK_TARGET_CPU_LEGACY_LIB}" | tr a-z A-Z)
14047   esac
14048 
14049 
14050 
14051 
14052 # Continue setting up basic stuff. Most remaining code require fundamental tools.
14053 
14054   # Save the current directory this script was started from
14055   CURDIR="$PWD"
14056 
14057   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
14058     PATH_SEP=";"
14059 
14060   SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
14061   if test $SRC_ROOT_LENGTH -gt 100; then
14062     as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
14063   fi
14064 
14065   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14066     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
14067 $as_echo_n "checking cygwin release... " >&6; }
14068     CYGWIN_VERSION=`$UNAME -r`
14069     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
14070 $as_echo "$CYGWIN_VERSION" >&6; }
14071     WINDOWS_ENV_VENDOR='cygwin'
14072     WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
14073 
14074     CYGWIN_VERSION_OLD=`$ECHO $CYGWIN_VERSION | $GREP -e '^1\.0-6'`
14075     if test "x$CYGWIN_VERSION_OLD" != x; then
14076       { $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
14077 $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;}
14078       as_fn_error $? "Cannot continue" "$LINENO" 5
14079     fi
14080     if test "x$CYGPATH" = x; then
14081       as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
14082     fi
14083     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
14084 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
14085     # The cmd output ends with Windows line endings (CR/LF)
14086     cygwin_winpath_root=`cd / ; cmd /c cd | $TR -d '\r\n'`
14087     # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
14088     CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
14089     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
14090 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
14091     WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
14092     test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
14093     if test "x$test_cygdrive_prefix" = x; then
14094       as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
14095     fi
14096   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14097     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
14098 $as_echo_n "checking msys release... " >&6; }
14099     MSYS_VERSION=`$UNAME -r`
14100     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
14101 $as_echo "$MSYS_VERSION" >&6; }
14102 
14103     WINDOWS_ENV_VENDOR='msys'
14104     WINDOWS_ENV_VERSION="$MSYS_VERSION"
14105 
14106     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
14107 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
14108     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
14109     MSYS_ROOT_PATH=`cd / ; cmd /c cd | grep ".*"`
14110 
14111   windows_path="$MSYS_ROOT_PATH"
14112   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14113     unix_path=`$CYGPATH -u "$windows_path"`
14114     MSYS_ROOT_PATH="$unix_path"
14115   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14116     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14117     MSYS_ROOT_PATH="$unix_path"
14118   fi
14119 
14120     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
14121 $as_echo "$MSYS_ROOT_PATH" >&6; }
14122     WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
14123   else
14124     as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
14125   fi
14126 
14127   # Test if windows or unix (cygwin/msys) find is first in path.
14128   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
14129 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
14130   FIND_BINARY_OUTPUT=`find --version 2>&1`
14131   if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
14132     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
14133 $as_echo "unix style" >&6; }
14134   elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
14135     { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
14136 $as_echo "Windows" >&6; }
14137     { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
14138 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
14139     { $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
14140 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
14141     as_fn_error $? "Cannot continue" "$LINENO" 5
14142   else
14143     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
14144 $as_echo "unknown" >&6; }
14145     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
14146 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
14147   fi
14148 
14149   else
14150     PATH_SEP=":"
14151   fi
14152 
14153 
14154   # We get the top-level directory from the supporting wrappers.
14155   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
14156 $as_echo_n "checking for top-level directory... " >&6; }
14157   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
14158 $as_echo "$TOPDIR" >&6; }
14159 
14160 
14161   # We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
14162 
14163   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14164 
14165   # Input might be given as Windows format, start by converting to
14166   # unix format.
14167   path="$CURDIR"
14168   new_path=`$CYGPATH -u "$path"`
14169 
14170   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14171   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14172   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14173   # "foo.exe" is OK but "foo" is an error.
14174   #
14175   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14176   # It is also a way to make sure we got the proper file name for the real test later on.
14177   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14178   if test "x$test_shortpath" = x; then
14179     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14180 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14181     as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
14182   fi
14183 
14184   # Call helper function which possibly converts this using DOS-style short mode.
14185   # If so, the updated path is stored in $new_path.
14186 
14187   input_path="$new_path"
14188   # Check if we need to convert this using DOS-style short mode. If the path
14189   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14190   # take no chances and rewrite it.
14191   # Note: m4 eats our [], so we need to use [ and ] instead.
14192   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14193   if test "x$has_forbidden_chars" != x; then
14194     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14195     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14196     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14197     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14198       # Going to short mode and back again did indeed matter. Since short mode is
14199       # case insensitive, let's make it lowercase to improve readability.
14200       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14201       # Now convert it back to Unix-style (cygpath)
14202       input_path=`$CYGPATH -u "$shortmode_path"`
14203       new_path="$input_path"
14204     fi
14205   fi
14206 
14207   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14208   if test "x$test_cygdrive_prefix" = x; then
14209     # As a simple fix, exclude /usr/bin since it's not a real path.
14210     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14211       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14212       # a path prefixed by /cygdrive for fixpath to work.
14213       new_path="$CYGWIN_ROOT_PATH$input_path"
14214     fi
14215   fi
14216 
14217 
14218   if test "x$path" != "x$new_path"; then
14219     CURDIR="$new_path"
14220     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14221 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14222   fi
14223 
14224   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14225 
14226   path="$CURDIR"
14227   has_colon=`$ECHO $path | $GREP ^.:`
14228   new_path="$path"
14229   if test "x$has_colon" = x; then
14230     # Not in mixed or Windows style, start by that.
14231     new_path=`cmd //c echo $path`
14232   fi
14233 
14234 
14235   input_path="$new_path"
14236   # Check if we need to convert this using DOS-style short mode. If the path
14237   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14238   # take no chances and rewrite it.
14239   # Note: m4 eats our [], so we need to use [ and ] instead.
14240   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14241   if test "x$has_forbidden_chars" != x; then
14242     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14243     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14244   fi
14245 
14246 
14247   windows_path="$new_path"
14248   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14249     unix_path=`$CYGPATH -u "$windows_path"`
14250     new_path="$unix_path"
14251   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14252     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14253     new_path="$unix_path"
14254   fi
14255 
14256   if test "x$path" != "x$new_path"; then
14257     CURDIR="$new_path"
14258     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14259 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14260   fi
14261 
14262   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14263   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14264 
14265   else
14266     # We're on a posix platform. Hooray! :)
14267     path="$CURDIR"
14268     has_space=`$ECHO "$path" | $GREP " "`
14269     if test "x$has_space" != x; then
14270       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14271 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14272       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14273     fi
14274 
14275     # Use eval to expand a potential ~
14276     eval path="$path"
14277     if test ! -f "$path" && test ! -d "$path"; then
14278       as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14279     fi
14280 
14281     CURDIR="`cd "$path"; $THEPWDCMD -L`"
14282   fi
14283 
14284 
14285   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14286 
14287   # Input might be given as Windows format, start by converting to
14288   # unix format.
14289   path="$TOPDIR"
14290   new_path=`$CYGPATH -u "$path"`
14291 
14292   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14293   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14294   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14295   # "foo.exe" is OK but "foo" is an error.
14296   #
14297   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14298   # It is also a way to make sure we got the proper file name for the real test later on.
14299   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14300   if test "x$test_shortpath" = x; then
14301     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14302 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14303     as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
14304   fi
14305 
14306   # Call helper function which possibly converts this using DOS-style short mode.
14307   # If so, the updated path is stored in $new_path.
14308 
14309   input_path="$new_path"
14310   # Check if we need to convert this using DOS-style short mode. If the path
14311   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14312   # take no chances and rewrite it.
14313   # Note: m4 eats our [], so we need to use [ and ] instead.
14314   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14315   if test "x$has_forbidden_chars" != x; then
14316     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14317     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14318     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14319     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14320       # Going to short mode and back again did indeed matter. Since short mode is
14321       # case insensitive, let's make it lowercase to improve readability.
14322       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14323       # Now convert it back to Unix-style (cygpath)
14324       input_path=`$CYGPATH -u "$shortmode_path"`
14325       new_path="$input_path"
14326     fi
14327   fi
14328 
14329   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14330   if test "x$test_cygdrive_prefix" = x; then
14331     # As a simple fix, exclude /usr/bin since it's not a real path.
14332     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14333       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14334       # a path prefixed by /cygdrive for fixpath to work.
14335       new_path="$CYGWIN_ROOT_PATH$input_path"
14336     fi
14337   fi
14338 
14339 
14340   if test "x$path" != "x$new_path"; then
14341     TOPDIR="$new_path"
14342     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14343 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14344   fi
14345 
14346   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14347 
14348   path="$TOPDIR"
14349   has_colon=`$ECHO $path | $GREP ^.:`
14350   new_path="$path"
14351   if test "x$has_colon" = x; then
14352     # Not in mixed or Windows style, start by that.
14353     new_path=`cmd //c echo $path`
14354   fi
14355 
14356 
14357   input_path="$new_path"
14358   # Check if we need to convert this using DOS-style short mode. If the path
14359   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14360   # take no chances and rewrite it.
14361   # Note: m4 eats our [], so we need to use [ and ] instead.
14362   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14363   if test "x$has_forbidden_chars" != x; then
14364     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14365     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14366   fi
14367 
14368 
14369   windows_path="$new_path"
14370   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14371     unix_path=`$CYGPATH -u "$windows_path"`
14372     new_path="$unix_path"
14373   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14374     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14375     new_path="$unix_path"
14376   fi
14377 
14378   if test "x$path" != "x$new_path"; then
14379     TOPDIR="$new_path"
14380     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14381 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14382   fi
14383 
14384   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14385   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14386 
14387   else
14388     # We're on a posix platform. Hooray! :)
14389     path="$TOPDIR"
14390     has_space=`$ECHO "$path" | $GREP " "`
14391     if test "x$has_space" != x; then
14392       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14393 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14394       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14395     fi
14396 
14397     # Use eval to expand a potential ~
14398     eval path="$path"
14399     if test ! -f "$path" && test ! -d "$path"; then
14400       as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14401     fi
14402 
14403     TOPDIR="`cd "$path"; $THEPWDCMD -L`"
14404   fi
14405 
14406   # SRC_ROOT is a traditional alias for TOPDIR.
14407   SRC_ROOT=$TOPDIR
14408 
14409   # Locate the directory of this script.
14410   AUTOCONF_DIR=$TOPDIR/common/autoconf
14411 
14412 
14413   # Setup default logging of stdout and stderr to build.log in the output root.
14414   BUILD_LOG='$(OUTPUT_ROOT)/build.log'
14415   BUILD_LOG_PREVIOUS='$(OUTPUT_ROOT)/build.log.old'
14416   BUILD_LOG_WRAPPER='$(BASH) $(SRC_ROOT)/common/bin/logger.sh $(BUILD_LOG)'
14417 
14418 
14419 
14420 
14421 
14422 # Check if it's a pure open build or if custom sources are to be used.
14423 
14424   # Check whether --enable-openjdk-only was given.
14425 if test "${enable_openjdk_only+set}" = set; then :
14426   enableval=$enable_openjdk_only;
14427 else
14428   enable_openjdk_only="no"
14429 fi
14430 
14431 
14432   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
14433 $as_echo_n "checking for presence of closed sources... " >&6; }
14434   if test -d "$SRC_ROOT/jdk/src/closed"; then
14435     CLOSED_SOURCE_PRESENT=yes
14436   else
14437     CLOSED_SOURCE_PRESENT=no
14438   fi
14439   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
14440 $as_echo "$CLOSED_SOURCE_PRESENT" >&6; }
14441 
14442   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
14443 $as_echo_n "checking if closed source is suppressed (openjdk-only)... " >&6; }
14444   SUPPRESS_CLOSED_SOURCE="$enable_openjdk_only"
14445   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
14446 $as_echo "$SUPPRESS_CLOSED_SOURCE" >&6; }
14447 
14448   if test "x$CLOSED_SOURCE_PRESENT" = xno; then
14449     OPENJDK=true
14450     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14451       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
14452 $as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
14453     fi
14454   else
14455     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14456       OPENJDK=true
14457     else
14458       OPENJDK=false
14459     fi
14460   fi
14461 
14462   if test "x$OPENJDK" = "xtrue"; then
14463     SET_OPENJDK="OPENJDK=true"
14464   fi
14465 
14466 
14467 
14468 
14469 # These are needed to be able to create a configuration name (and thus the output directory)
14470 
14471   ###############################################################################
14472   #
14473   # Check which variant of the JDK that we want to build.
14474   # Currently we have:
14475   #    normal:   standard edition
14476   # but the custom make system may add other variants
14477   #
14478   # Effectively the JDK variant gives a name to a specific set of
14479   # modules to compile into the JDK. In the future, these modules
14480   # might even be Jigsaw modules.
14481   #
14482   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
14483 $as_echo_n "checking which variant of the JDK to build... " >&6; }
14484 
14485 # Check whether --with-jdk-variant was given.
14486 if test "${with_jdk_variant+set}" = set; then :
14487   withval=$with_jdk_variant;
14488 fi
14489 
14490 
14491   if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
14492     JDK_VARIANT="normal"
14493   else
14494     as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
14495   fi
14496 
14497 
14498 
14499   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
14500 $as_echo "$JDK_VARIANT" >&6; }
14501 
14502 
14503 ###############################################################################
14504 #
14505 # Check which interpreter of the JVM we want to build.
14506 # Currently we have:
14507 #    template: Template interpreter (the default)
14508 #    cpp     : C++ interpreter
14509 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which interpreter of the JVM to build" >&5
14510 $as_echo_n "checking which interpreter of the JVM to build... " >&6; }
14511 
14512 # Check whether --with-jvm-interpreter was given.
14513 if test "${with_jvm_interpreter+set}" = set; then :
14514   withval=$with_jvm_interpreter;
14515 fi
14516 
14517 
14518 if test "x$with_jvm_interpreter" = x; then
14519      with_jvm_interpreter="template"
14520 fi
14521 
14522 JVM_INTERPRETER="$with_jvm_interpreter"
14523 
14524 if test "x$JVM_INTERPRETER" != xtemplate && test "x$JVM_INTERPRETER" != xcpp; then
14525    as_fn_error $? "The available JVM interpreters are: template, cpp" "$LINENO" 5
14526 fi
14527 
14528 
14529 
14530 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_interpreter" >&5
14531 $as_echo "$with_jvm_interpreter" >&6; }
14532 
14533 
14534 
14535   ###############################################################################
14536   #
14537   # Check which variants of the JVM that we want to build.
14538   # Currently we have:
14539   #    server: normal interpreter and a tiered C1/C2 compiler
14540   #    client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms)
14541   #    minimal1: reduced form of client with optional VM services and features stripped out
14542   #    kernel: kernel footprint JVM that passes the TCK without major performance problems,
14543   #             ie normal interpreter and C1, only the serial GC, kernel jvmti etc
14544   #    zero: no machine code interpreter, no compiler
14545   #    zeroshark: zero interpreter and shark/llvm compiler backend
14546 #    core: interpreter only, no compiler (only works on some platforms)
14547   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
14548 $as_echo_n "checking which variants of the JVM to build... " >&6; }
14549 
14550 # Check whether --with-jvm-variants was given.
14551 if test "${with_jvm_variants+set}" = set; then :
14552   withval=$with_jvm_variants;
14553 fi
14554 
14555 
14556   if test "x$with_jvm_variants" = x; then
14557     with_jvm_variants="server"
14558   fi
14559 
14560   JVM_VARIANTS=",$with_jvm_variants,"
14561   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,//'`
14562 
14563   if test "x$TEST_VARIANTS" != "x,"; then
14564      as_fn_error $? "The available JVM variants are: server, client, minimal1, kernel, zero, zeroshark, core" "$LINENO" 5
14565   fi
14566   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5
14567 $as_echo "$with_jvm_variants" >&6; }
14568 
14569   JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'`
14570   JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'`
14571   JVM_VARIANT_MINIMAL1=`$ECHO "$JVM_VARIANTS" | $SED -e '/,minimal1,/!s/.*/false/g' -e '/,minimal1,/s/.*/true/g'`
14572   JVM_VARIANT_KERNEL=`$ECHO "$JVM_VARIANTS" | $SED -e '/,kernel,/!s/.*/false/g' -e '/,kernel,/s/.*/true/g'`
14573   JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'`
14574   JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'`
14575   JVM_VARIANT_CORE=`$ECHO "$JVM_VARIANTS" | $SED -e '/,core,/!s/.*/false/g' -e '/,core,/s/.*/true/g'`
14576 
14577   if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14578     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14579       as_fn_error $? "You cannot build a client JVM for a 64-bit machine." "$LINENO" 5
14580     fi
14581   fi
14582   if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14583     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14584       as_fn_error $? "You cannot build a kernel JVM for a 64-bit machine." "$LINENO" 5
14585     fi
14586   fi
14587   if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14588     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14589       as_fn_error $? "You cannot build a minimal JVM for a 64-bit machine." "$LINENO" 5
14590     fi
14591   fi
14592 
14593   # Replace the commas with AND for use in the build directory name.
14594   ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/g'`
14595   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/'`
14596   if test "x$COUNT_VARIANTS" != "x,1"; then
14597     BUILDING_MULTIPLE_JVM_VARIANTS=yes
14598   else
14599     BUILDING_MULTIPLE_JVM_VARIANTS=no
14600   fi
14601 
14602 
14603 
14604 
14605 
14606 
14607 
14608 
14609 
14610 
14611   INCLUDE_SA=true
14612   if test "x$JVM_VARIANT_ZERO" = xtrue ; then
14613     INCLUDE_SA=false
14614   fi
14615   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue ; then
14616     INCLUDE_SA=false
14617   fi
14618   if test "x$VAR_CPU" = xppc64 -o "x$VAR_CPU" = xppc64le ; then
14619     INCLUDE_SA=false
14620   fi
14621 
14622 
14623   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
14624     MACOSX_UNIVERSAL="false"
14625   fi
14626 
14627 
14628 
14629 
14630   ###############################################################################
14631   #
14632   # Set the debug level
14633   #    release: no debug information, all optimizations, no asserts.
14634   #    fastdebug: debug information (-g), all optimizations, all asserts
14635   #    slowdebug: debug information (-g), no optimizations, all asserts
14636   #
14637   DEBUG_LEVEL="release"
14638   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
14639 $as_echo_n "checking which debug level to use... " >&6; }
14640   # Check whether --enable-debug was given.
14641 if test "${enable_debug+set}" = set; then :
14642   enableval=$enable_debug;
14643         ENABLE_DEBUG="${enableval}"
14644         DEBUG_LEVEL="fastdebug"
14645 
14646 else
14647   ENABLE_DEBUG="no"
14648 fi
14649 
14650 
14651 
14652 # Check whether --with-debug-level was given.
14653 if test "${with_debug_level+set}" = set; then :
14654   withval=$with_debug_level;
14655         DEBUG_LEVEL="${withval}"
14656         if test "x$ENABLE_DEBUG" = xyes; then
14657           as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
14658         fi
14659 
14660 fi
14661 
14662   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
14663 $as_echo "$DEBUG_LEVEL" >&6; }
14664 
14665   if test "x$DEBUG_LEVEL" != xrelease && \
14666       test "x$DEBUG_LEVEL" != xfastdebug && \
14667       test "x$DEBUG_LEVEL" != xslowdebug; then
14668     as_fn_error $? "Allowed debug levels are: release, fastdebug and slowdebug" "$LINENO" 5
14669   fi
14670 
14671 
14672   ###############################################################################
14673   #
14674   # Setup legacy vars/targets and new vars to deal with different debug levels.
14675   #
14676 
14677   case $DEBUG_LEVEL in
14678     release )
14679       VARIANT="OPT"
14680       FASTDEBUG="false"
14681       DEBUG_CLASSFILES="false"
14682       BUILD_VARIANT_RELEASE=""
14683       HOTSPOT_DEBUG_LEVEL="product"
14684       HOTSPOT_EXPORT="product"
14685       ;;
14686     fastdebug )
14687       VARIANT="DBG"
14688       FASTDEBUG="true"
14689       DEBUG_CLASSFILES="true"
14690       BUILD_VARIANT_RELEASE="-fastdebug"
14691       HOTSPOT_DEBUG_LEVEL="fastdebug"
14692       HOTSPOT_EXPORT="fastdebug"
14693       ;;
14694     slowdebug )
14695       VARIANT="DBG"
14696       FASTDEBUG="false"
14697       DEBUG_CLASSFILES="true"
14698       BUILD_VARIANT_RELEASE="-debug"
14699       HOTSPOT_DEBUG_LEVEL="jvmg"
14700       HOTSPOT_EXPORT="debug"
14701       ;;
14702   esac
14703 
14704   #####
14705   # Generate the legacy makefile targets for hotspot.
14706   # The hotspot api for selecting the build artifacts, really, needs to be improved.
14707   # JDK-7195896 will fix this on the hotspot side by using the JVM_VARIANT_* variables to
14708   # determine what needs to be built. All we will need to set here is all_product, all_fastdebug etc
14709   # But until then ...
14710   HOTSPOT_TARGET=""
14711 
14712   if test "x$JVM_VARIANT_SERVER" = xtrue; then
14713     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL} "
14714   fi
14715 
14716   if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14717     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}1 "
14718   fi
14719 
14720   if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14721     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}minimal1 "
14722   fi
14723 
14724   if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14725     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}kernel "
14726   fi
14727 
14728   if test "x$JVM_VARIANT_ZERO" = xtrue; then
14729     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}zero "
14730   fi
14731 
14732   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
14733     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}shark "
14734   fi
14735 
14736   if test "x$JVM_VARIANT_CORE" = xtrue; then
14737     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}core "
14738   fi
14739 
14740   HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT"
14741 
14742   # On Macosx universal binaries are produced, but they only contain
14743   # 64 bit intel. This invalidates control of which jvms are built
14744   # from configure, but only server is valid anyway. Fix this
14745   # when hotspot makefiles are rewritten.
14746   if test "x$MACOSX_UNIVERSAL" = xtrue; then
14747     HOTSPOT_TARGET=universal_${HOTSPOT_EXPORT}
14748   fi
14749 
14750   #####
14751 
14752 
14753 
14754 
14755 
14756 
14757 
14758 
14759 # With basic setup done, call the custom early hook.
14760 
14761 
14762 # Check if we have devkits, extra paths or sysroot set.
14763 
14764 
14765 # Check whether --with-devkit was given.
14766 if test "${with_devkit+set}" = set; then :
14767   withval=$with_devkit;
14768 fi
14769 
14770 
14771   if test "x$with_devkit" = xyes; then
14772     as_fn_error $? "--with-devkit must have a value" "$LINENO" 5
14773   elif test "x$with_devkit" != x && test "x$with_devkit" != xno; then
14774 
14775   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14776 
14777   # Input might be given as Windows format, start by converting to
14778   # unix format.
14779   path="$with_devkit"
14780   new_path=`$CYGPATH -u "$path"`
14781 
14782   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14783   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14784   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14785   # "foo.exe" is OK but "foo" is an error.
14786   #
14787   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14788   # It is also a way to make sure we got the proper file name for the real test later on.
14789   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14790   if test "x$test_shortpath" = x; then
14791     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14792 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14793     as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
14794   fi
14795 
14796   # Call helper function which possibly converts this using DOS-style short mode.
14797   # If so, the updated path is stored in $new_path.
14798 
14799   input_path="$new_path"
14800   # Check if we need to convert this using DOS-style short mode. If the path
14801   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14802   # take no chances and rewrite it.
14803   # Note: m4 eats our [], so we need to use [ and ] instead.
14804   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14805   if test "x$has_forbidden_chars" != x; then
14806     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14807     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14808     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14809     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14810       # Going to short mode and back again did indeed matter. Since short mode is
14811       # case insensitive, let's make it lowercase to improve readability.
14812       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14813       # Now convert it back to Unix-style (cygpath)
14814       input_path=`$CYGPATH -u "$shortmode_path"`
14815       new_path="$input_path"
14816     fi
14817   fi
14818 
14819   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14820   if test "x$test_cygdrive_prefix" = x; then
14821     # As a simple fix, exclude /usr/bin since it's not a real path.
14822     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14823       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14824       # a path prefixed by /cygdrive for fixpath to work.
14825       new_path="$CYGWIN_ROOT_PATH$input_path"
14826     fi
14827   fi
14828 
14829 
14830   if test "x$path" != "x$new_path"; then
14831     with_devkit="$new_path"
14832     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14833 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14834   fi
14835 
14836   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14837 
14838   path="$with_devkit"
14839   has_colon=`$ECHO $path | $GREP ^.:`
14840   new_path="$path"
14841   if test "x$has_colon" = x; then
14842     # Not in mixed or Windows style, start by that.
14843     new_path=`cmd //c echo $path`
14844   fi
14845 
14846 
14847   input_path="$new_path"
14848   # Check if we need to convert this using DOS-style short mode. If the path
14849   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14850   # take no chances and rewrite it.
14851   # Note: m4 eats our [], so we need to use [ and ] instead.
14852   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14853   if test "x$has_forbidden_chars" != x; then
14854     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14855     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14856   fi
14857 
14858 
14859   windows_path="$new_path"
14860   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14861     unix_path=`$CYGPATH -u "$windows_path"`
14862     new_path="$unix_path"
14863   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14864     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14865     new_path="$unix_path"
14866   fi
14867 
14868   if test "x$path" != "x$new_path"; then
14869     with_devkit="$new_path"
14870     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14871 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14872   fi
14873 
14874   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14875   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14876 
14877   else
14878     # We're on a posix platform. Hooray! :)
14879     path="$with_devkit"
14880     has_space=`$ECHO "$path" | $GREP " "`
14881     if test "x$has_space" != x; then
14882       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14883 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14884       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14885     fi
14886 
14887     # Use eval to expand a potential ~
14888     eval path="$path"
14889     if test ! -f "$path" && test ! -d "$path"; then
14890       as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
14891     fi
14892 
14893     with_devkit="`cd "$path"; $THEPWDCMD -L`"
14894   fi
14895 
14896     DEVKIT_ROOT="$with_devkit"
14897     # Check for a meta data info file in the root of the devkit
14898     if test -f "$DEVKIT_ROOT/devkit.info"; then
14899       . $DEVKIT_ROOT/devkit.info
14900       # This potentially sets the following:
14901       # A descriptive name of the devkit
14902 
14903   if test "x$DEVKIT_NAME" = x; then
14904     eval DEVKIT_NAME="\${DEVKIT_NAME_${OPENJDK_TARGET_CPU}}"
14905   fi
14906 
14907       # Corresponds to --with-extra-path
14908 
14909   if test "x$DEVKIT_EXTRA_PATH" = x; then
14910     eval DEVKIT_EXTRA_PATH="\${DEVKIT_EXTRA_PATH_${OPENJDK_TARGET_CPU}}"
14911   fi
14912 
14913       # Corresponds to --with-toolchain-path
14914 
14915   if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
14916     eval DEVKIT_TOOLCHAIN_PATH="\${DEVKIT_TOOLCHAIN_PATH_${OPENJDK_TARGET_CPU}}"
14917   fi
14918 
14919       # Corresponds to --with-sysroot
14920 
14921   if test "x$DEVKIT_SYSROOT" = x; then
14922     eval DEVKIT_SYSROOT="\${DEVKIT_SYSROOT_${OPENJDK_TARGET_CPU}}"
14923   fi
14924 
14925 
14926       # Identifies the Visual Studio version in the devkit
14927 
14928   if test "x$DEVKIT_VS_VERSION" = x; then
14929     eval DEVKIT_VS_VERSION="\${DEVKIT_VS_VERSION_${OPENJDK_TARGET_CPU}}"
14930   fi
14931 
14932       # The Visual Studio include environment variable
14933 
14934   if test "x$DEVKIT_VS_INCLUDE" = x; then
14935     eval DEVKIT_VS_INCLUDE="\${DEVKIT_VS_INCLUDE_${OPENJDK_TARGET_CPU}}"
14936   fi
14937 
14938       # The Visual Studio lib environment variable
14939 
14940   if test "x$DEVKIT_VS_LIB" = x; then
14941     eval DEVKIT_VS_LIB="\${DEVKIT_VS_LIB_${OPENJDK_TARGET_CPU}}"
14942   fi
14943 
14944       # Corresponds to --with-msvcr-dll
14945 
14946   if test "x$DEVKIT_MSVCR_DLL" = x; then
14947     eval DEVKIT_MSVCR_DLL="\${DEVKIT_MSVCR_DLL_${OPENJDK_TARGET_CPU}}"
14948   fi
14949 
14950       # Corresponds to --with-msvcp-dll
14951 
14952   if test "x$DEVKIT_MSVCP_DLL" = x; then
14953     eval DEVKIT_MSVCP_DLL="\${DEVKIT_MSVCP_DLL_${OPENJDK_TARGET_CPU}}"
14954   fi
14955 
14956       # Corresponds to --with-ucrt-dll-dir
14957 
14958   if test "x$DEVKIT_UCRT_DLL_DIR" = x; then
14959     eval DEVKIT_UCRT_DLL_DIR="\${DEVKIT_UCRT_DLL_DIR_${OPENJDK_TARGET_CPU}}"
14960   fi
14961 
14962     fi
14963 
14964     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
14965 $as_echo_n "checking for devkit... " >&6; }
14966     if test "x$DEVKIT_NAME" != x; then
14967       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
14968 $as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
14969     else
14970       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
14971 $as_echo "$DEVKIT_ROOT" >&6; }
14972     fi
14973 
14974 
14975   if test "x$DEVKIT_EXTRA_PATH" != x; then
14976     if test "x$EXTRA_PATH" = x; then
14977       EXTRA_PATH="$DEVKIT_EXTRA_PATH"
14978     else
14979       EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH"
14980     fi
14981   fi
14982 
14983 
14984     # Fallback default of just /bin if DEVKIT_PATH is not defined
14985     if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
14986       DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin"
14987     fi
14988 
14989   if test "x$DEVKIT_TOOLCHAIN_PATH" != x; then
14990     if test "x$TOOLCHAIN_PATH" = x; then
14991       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH"
14992     else
14993       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH:$TOOLCHAIN_PATH"
14994     fi
14995   fi
14996 
14997 
14998     # If DEVKIT_SYSROOT is set, use that, otherwise try a couple of known
14999     # places for backwards compatiblity.
15000     if test "x$DEVKIT_SYSROOT" != x; then
15001       SYSROOT="$DEVKIT_SYSROOT"
15002     elif test -d "$DEVKIT_ROOT/$host_alias/libc"; then
15003       SYSROOT="$DEVKIT_ROOT/$host_alias/libc"
15004     elif test -d "$DEVKIT_ROOT/$host/sys-root"; then
15005       SYSROOT="$DEVKIT_ROOT/$host/sys-root"
15006     fi
15007 
15008     if test "x$DEVKIT_ROOT" != x; then
15009       DEVKIT_LIB_DIR="$DEVKIT_ROOT/lib"
15010       if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
15011         DEVKIT_LIB_DIR="$DEVKIT_ROOT/lib64"
15012       fi
15013 
15014     fi
15015   fi
15016 
15017   # You can force the sysroot if the sysroot encoded into the compiler tools
15018   # is not correct.
15019 
15020 # Check whether --with-sys-root was given.
15021 if test "${with_sys_root+set}" = set; then :
15022   withval=$with_sys_root; SYSROOT=$with_sys_root
15023 
15024 fi
15025 
15026 
15027 
15028 # Check whether --with-sysroot was given.
15029 if test "${with_sysroot+set}" = set; then :
15030   withval=$with_sysroot; SYSROOT=$with_sysroot
15031 
15032 fi
15033 
15034 
15035 
15036 # Check whether --with-tools-dir was given.
15037 if test "${with_tools_dir+set}" = set; then :
15038   withval=$with_tools_dir;
15039   if test "x$with_tools_dir" != x; then
15040     if test "x$TOOLCHAIN_PATH" = x; then
15041       TOOLCHAIN_PATH="$with_tools_dir"
15042     else
15043       TOOLCHAIN_PATH="$with_tools_dir:$TOOLCHAIN_PATH"
15044     fi
15045   fi
15046 
15047 
15048 fi
15049 
15050 
15051 
15052 # Check whether --with-toolchain-path was given.
15053 if test "${with_toolchain_path+set}" = set; then :
15054   withval=$with_toolchain_path;
15055   if test "x$with_toolchain_path" != x; then
15056     if test "x$TOOLCHAIN_PATH" = x; then
15057       TOOLCHAIN_PATH="$with_toolchain_path"
15058     else
15059       TOOLCHAIN_PATH="$with_toolchain_path:$TOOLCHAIN_PATH"
15060     fi
15061   fi
15062 
15063 
15064 fi
15065 
15066 
15067 
15068 # Check whether --with-extra-path was given.
15069 if test "${with_extra_path+set}" = set; then :
15070   withval=$with_extra_path;
15071   if test "x$with_extra_path" != x; then
15072     if test "x$EXTRA_PATH" = x; then
15073       EXTRA_PATH="$with_extra_path"
15074     else
15075       EXTRA_PATH="$with_extra_path:$EXTRA_PATH"
15076     fi
15077   fi
15078 
15079 
15080 fi
15081 
15082 
15083   # Prepend the extra path to the global path
15084 
15085   if test "x$EXTRA_PATH" != x; then
15086     if test "x$PATH" = x; then
15087       PATH="$EXTRA_PATH"
15088     else
15089       PATH="$EXTRA_PATH:$PATH"
15090     fi
15091   fi
15092 
15093 
15094   if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
15095     # Add extra search paths on solaris for utilities like ar and as etc...
15096     PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin"
15097   fi
15098 
15099   # Xcode version will be validated later
15100 
15101 # Check whether --with-xcode-path was given.
15102 if test "${with_xcode_path+set}" = set; then :
15103   withval=$with_xcode_path; XCODE_PATH=$with_xcode_path
15104 
15105 fi
15106 
15107 
15108   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
15109 $as_echo_n "checking for sysroot... " >&6; }
15110   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
15111 $as_echo "$SYSROOT" >&6; }
15112   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
15113 $as_echo_n "checking for toolchain path... " >&6; }
15114   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
15115 $as_echo "$TOOLCHAIN_PATH" >&6; }
15116   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
15117 $as_echo_n "checking for extra path... " >&6; }
15118   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
15119 $as_echo "$EXTRA_PATH" >&6; }
15120 
15121 
15122 # To properly create a configuration name, we need to have the OpenJDK target
15123 # and options (variants and debug level) parsed.
15124 
15125 
15126 
15127 # Check whether --with-conf-name was given.
15128 if test "${with_conf_name+set}" = set; then :
15129   withval=$with_conf_name;  CONF_NAME=${with_conf_name}
15130 fi
15131 
15132 
15133   # Test from where we are running configure, in or outside of src root.
15134   { $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
15135 $as_echo_n "checking where to store configuration... " >&6; }
15136   if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
15137       || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
15138       || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
15139     # We are running configure from the src root.
15140     # Create a default ./build/target-variant-debuglevel output root.
15141     if test "x${CONF_NAME}" = x; then
15142       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
15143 $as_echo "in default location" >&6; }
15144       CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}"
15145     else
15146       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
15147 $as_echo "in build directory with custom name" >&6; }
15148     fi
15149     OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
15150     $MKDIR -p "$OUTPUT_ROOT"
15151     if test ! -d "$OUTPUT_ROOT"; then
15152       as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
15153     fi
15154   else
15155     # We are running configure from outside of the src dir.
15156     # Then use the current directory as output dir!
15157     # If configuration is situated in normal build directory, just use the build
15158     # directory name as configuration name, otherwise use the complete path.
15159     if test "x${CONF_NAME}" = x; then
15160       CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
15161     fi
15162     OUTPUT_ROOT="$CURDIR"
15163     { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
15164 $as_echo "in current directory" >&6; }
15165 
15166     # WARNING: This might be a bad thing to do. You need to be sure you want to
15167     # have a configuration in this directory. Do some sanity checks!
15168 
15169     if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
15170       # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
15171       # other files
15172       files_present=`$LS $OUTPUT_ROOT`
15173       # Configure has already touched config.log and confdefs.h in the current dir when this check
15174       # is performed.
15175       filtered_files=`$ECHO "$files_present" \
15176           | $SED -e 's/config.log//g' \
15177               -e 's/confdefs.h//g' \
15178               -e 's/fixpath.exe//g' \
15179               -e 's/ //g' \
15180           | $TR -d '\n'`
15181       if test "x$filtered_files" != x; then
15182         { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
15183 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
15184         { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
15185 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
15186         { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
15187 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
15188         { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
15189 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
15190         { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
15191 $as_echo "$as_me: seriously mess up just about everything." >&6;}
15192         { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
15193 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
15194         { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
15195 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
15196         as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
15197       fi
15198     fi
15199   fi
15200   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
15201 $as_echo_n "checking what configuration name to use... " >&6; }
15202   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
15203 $as_echo "$CONF_NAME" >&6; }
15204 
15205 
15206   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15207 
15208   # Input might be given as Windows format, start by converting to
15209   # unix format.
15210   path="$OUTPUT_ROOT"
15211   new_path=`$CYGPATH -u "$path"`
15212 
15213   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15214   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15215   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15216   # "foo.exe" is OK but "foo" is an error.
15217   #
15218   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15219   # It is also a way to make sure we got the proper file name for the real test later on.
15220   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15221   if test "x$test_shortpath" = x; then
15222     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
15223 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
15224     as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
15225   fi
15226 
15227   # Call helper function which possibly converts this using DOS-style short mode.
15228   # If so, the updated path is stored in $new_path.
15229 
15230   input_path="$new_path"
15231   # Check if we need to convert this using DOS-style short mode. If the path
15232   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15233   # take no chances and rewrite it.
15234   # Note: m4 eats our [], so we need to use [ and ] instead.
15235   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15236   if test "x$has_forbidden_chars" != x; then
15237     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15238     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15239     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15240     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15241       # Going to short mode and back again did indeed matter. Since short mode is
15242       # case insensitive, let's make it lowercase to improve readability.
15243       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15244       # Now convert it back to Unix-style (cygpath)
15245       input_path=`$CYGPATH -u "$shortmode_path"`
15246       new_path="$input_path"
15247     fi
15248   fi
15249 
15250   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15251   if test "x$test_cygdrive_prefix" = x; then
15252     # As a simple fix, exclude /usr/bin since it's not a real path.
15253     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15254       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15255       # a path prefixed by /cygdrive for fixpath to work.
15256       new_path="$CYGWIN_ROOT_PATH$input_path"
15257     fi
15258   fi
15259 
15260 
15261   if test "x$path" != "x$new_path"; then
15262     OUTPUT_ROOT="$new_path"
15263     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15264 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15265   fi
15266 
15267   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15268 
15269   path="$OUTPUT_ROOT"
15270   has_colon=`$ECHO $path | $GREP ^.:`
15271   new_path="$path"
15272   if test "x$has_colon" = x; then
15273     # Not in mixed or Windows style, start by that.
15274     new_path=`cmd //c echo $path`
15275   fi
15276 
15277 
15278   input_path="$new_path"
15279   # Check if we need to convert this using DOS-style short mode. If the path
15280   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15281   # take no chances and rewrite it.
15282   # Note: m4 eats our [], so we need to use [ and ] instead.
15283   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15284   if test "x$has_forbidden_chars" != x; then
15285     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15286     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15287   fi
15288 
15289 
15290   windows_path="$new_path"
15291   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15292     unix_path=`$CYGPATH -u "$windows_path"`
15293     new_path="$unix_path"
15294   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15295     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15296     new_path="$unix_path"
15297   fi
15298 
15299   if test "x$path" != "x$new_path"; then
15300     OUTPUT_ROOT="$new_path"
15301     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15302 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15303   fi
15304 
15305   # Save the first 10 bytes of this path to the storage, so fixpath can work.
15306   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15307 
15308   else
15309     # We're on a posix platform. Hooray! :)
15310     path="$OUTPUT_ROOT"
15311     has_space=`$ECHO "$path" | $GREP " "`
15312     if test "x$has_space" != x; then
15313       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
15314 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
15315       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15316     fi
15317 
15318     # Use eval to expand a potential ~
15319     eval path="$path"
15320     if test ! -f "$path" && test ! -d "$path"; then
15321       as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
15322     fi
15323 
15324     OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
15325   fi
15326 
15327 
15328   SPEC=$OUTPUT_ROOT/spec.gmk
15329 
15330   CONF_NAME=$CONF_NAME
15331 
15332   OUTPUT_ROOT=$OUTPUT_ROOT
15333 
15334 
15335   # Most of the probed defines are put into config.h
15336   ac_config_headers="$ac_config_headers $OUTPUT_ROOT/config.h:$AUTOCONF_DIR/config.h.in"
15337 
15338   # The spec.gmk file contains all variables for the make system.
15339   ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
15340 
15341   # The hotspot-spec.gmk file contains legacy variables for the hotspot make system.
15342   ac_config_files="$ac_config_files $OUTPUT_ROOT/hotspot-spec.gmk:$AUTOCONF_DIR/hotspot-spec.gmk.in"
15343 
15344   # The bootcycle-spec.gmk file contains support for boot cycle builds.
15345   ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
15346 
15347   # The compare.sh is used to compare the build output to other builds.
15348   ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
15349 
15350   # Spec.sh is currently used by compare-objects.sh
15351   ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.sh:$AUTOCONF_DIR/spec.sh.in"
15352 
15353   # The generated Makefile knows where the spec.gmk is and where the source is.
15354   # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
15355   # which will look for generated configurations
15356   ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
15357 
15358 
15359 
15360 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
15361 
15362   for ac_prog in apt-get yum port pkgutil pkgadd
15363 do
15364   # Extract the first word of "$ac_prog", so it can be a program name with args.
15365 set dummy $ac_prog; ac_word=$2
15366 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15367 $as_echo_n "checking for $ac_word... " >&6; }
15368 if ${ac_cv_prog_PKGHANDLER+:} false; then :
15369   $as_echo_n "(cached) " >&6
15370 else
15371   if test -n "$PKGHANDLER"; then
15372   ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
15373 else
15374 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15375 for as_dir in $PATH
15376 do
15377   IFS=$as_save_IFS
15378   test -z "$as_dir" && as_dir=.
15379     for ac_exec_ext in '' $ac_executable_extensions; do
15380   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15381     ac_cv_prog_PKGHANDLER="$ac_prog"
15382     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15383     break 2
15384   fi
15385 done
15386   done
15387 IFS=$as_save_IFS
15388 
15389 fi
15390 fi
15391 PKGHANDLER=$ac_cv_prog_PKGHANDLER
15392 if test -n "$PKGHANDLER"; then
15393   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
15394 $as_echo "$PKGHANDLER" >&6; }
15395 else
15396   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15397 $as_echo "no" >&6; }
15398 fi
15399 
15400 
15401   test -n "$PKGHANDLER" && break
15402 done
15403 
15404 
15405 
15406 # Setup tools that requires more complex handling, or that is not needed by the configure script.
15407 
15408 
15409   # We need to find a recent version of GNU make. Especially on Solaris, this can be tricky.
15410   if test "x$MAKE" != x; then
15411     # User has supplied a make, test it.
15412     if test ! -f "$MAKE"; then
15413       as_fn_error $? "The specified make (by MAKE=$MAKE) is not found." "$LINENO" 5
15414     fi
15415 
15416   MAKE_CANDIDATE=""$MAKE""
15417   DESCRIPTION="user supplied MAKE=$MAKE"
15418   if test "x$MAKE_CANDIDATE" != x; then
15419     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15420 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15421     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15422     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15423     if test "x$IS_GNU_MAKE" = x; then
15424       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15425 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15426     else
15427       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15428       if test "x$IS_MODERN_MAKE" = x; then
15429         { $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
15430 $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;}
15431       else
15432         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15433           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15434             MAKE_EXPECTED_ENV='cygwin'
15435           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15436             MAKE_EXPECTED_ENV='msys'
15437           else
15438             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15439           fi
15440           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15441           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15442         else
15443           # Not relevant for non-Windows
15444           IS_MAKE_CORRECT_ENV=true
15445         fi
15446         if test "x$IS_MAKE_CORRECT_ENV" = x; then
15447           { $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
15448 $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;}
15449         else
15450           FOUND_MAKE=$MAKE_CANDIDATE
15451 
15452   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15453 
15454   # First separate the path from the arguments. This will split at the first
15455   # space.
15456   complete="$FOUND_MAKE"
15457   path="${complete%% *}"
15458   tmp="$complete EOL"
15459   arguments="${tmp#* }"
15460 
15461   # Input might be given as Windows format, start by converting to
15462   # unix format.
15463   new_path=`$CYGPATH -u "$path"`
15464 
15465   # Now try to locate executable using which
15466   new_path=`$WHICH "$new_path" 2> /dev/null`
15467   # bat and cmd files are not always considered executable in cygwin causing which
15468   # to not find them
15469   if test "x$new_path" = x \
15470       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15471       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15472     new_path=`$CYGPATH -u "$path"`
15473   fi
15474   if test "x$new_path" = x; then
15475     # Oops. Which didn't find the executable.
15476     # The splitting of arguments from the executable at a space might have been incorrect,
15477     # since paths with space are more likely in Windows. Give it another try with the whole
15478     # argument.
15479     path="$complete"
15480     arguments="EOL"
15481     new_path=`$CYGPATH -u "$path"`
15482     new_path=`$WHICH "$new_path" 2> /dev/null`
15483     # bat and cmd files are not always considered executable in cygwin causing which
15484     # to not find them
15485     if test "x$new_path" = x \
15486         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15487         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15488       new_path=`$CYGPATH -u "$path"`
15489     fi
15490     if test "x$new_path" = x; then
15491       # It's still not found. Now this is an unrecoverable error.
15492       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15493 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15494       has_space=`$ECHO "$complete" | $GREP " "`
15495       if test "x$has_space" != x; then
15496         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15497 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15498       fi
15499       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15500     fi
15501   fi
15502 
15503   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15504   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15505   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15506   # "foo.exe" is OK but "foo" is an error.
15507   #
15508   # This test is therefore slightly more accurate than "test -f" to check for file presence.
15509   # It is also a way to make sure we got the proper file name for the real test later on.
15510   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15511   if test "x$test_shortpath" = x; then
15512     # Short path failed, file does not exist as specified.
15513     # Try adding .exe or .cmd
15514     if test -f "${new_path}.exe"; then
15515       input_to_shortpath="${new_path}.exe"
15516     elif test -f "${new_path}.cmd"; then
15517       input_to_shortpath="${new_path}.cmd"
15518     else
15519       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15520 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15521       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15522 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15523       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15524     fi
15525   else
15526     input_to_shortpath="$new_path"
15527   fi
15528 
15529   # Call helper function which possibly converts this using DOS-style short mode.
15530   # If so, the updated path is stored in $new_path.
15531   new_path="$input_to_shortpath"
15532 
15533   input_path="$input_to_shortpath"
15534   # Check if we need to convert this using DOS-style short mode. If the path
15535   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15536   # take no chances and rewrite it.
15537   # Note: m4 eats our [], so we need to use [ and ] instead.
15538   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15539   if test "x$has_forbidden_chars" != x; then
15540     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15541     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15542     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15543     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15544       # Going to short mode and back again did indeed matter. Since short mode is
15545       # case insensitive, let's make it lowercase to improve readability.
15546       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15547       # Now convert it back to Unix-style (cygpath)
15548       input_path=`$CYGPATH -u "$shortmode_path"`
15549       new_path="$input_path"
15550     fi
15551   fi
15552 
15553   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15554   if test "x$test_cygdrive_prefix" = x; then
15555     # As a simple fix, exclude /usr/bin since it's not a real path.
15556     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15557       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15558       # a path prefixed by /cygdrive for fixpath to work.
15559       new_path="$CYGWIN_ROOT_PATH$input_path"
15560     fi
15561   fi
15562 
15563   # remove trailing .exe if any
15564   new_path="${new_path/%.exe/}"
15565 
15566   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15567 
15568   # First separate the path from the arguments. This will split at the first
15569   # space.
15570   complete="$FOUND_MAKE"
15571   path="${complete%% *}"
15572   tmp="$complete EOL"
15573   arguments="${tmp#* }"
15574 
15575   # Input might be given as Windows format, start by converting to
15576   # unix format.
15577   new_path="$path"
15578 
15579   windows_path="$new_path"
15580   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15581     unix_path=`$CYGPATH -u "$windows_path"`
15582     new_path="$unix_path"
15583   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15584     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15585     new_path="$unix_path"
15586   fi
15587 
15588 
15589   # Now try to locate executable using which
15590   new_path=`$WHICH "$new_path" 2> /dev/null`
15591 
15592   if test "x$new_path" = x; then
15593     # Oops. Which didn't find the executable.
15594     # The splitting of arguments from the executable at a space might have been incorrect,
15595     # since paths with space are more likely in Windows. Give it another try with the whole
15596     # argument.
15597     path="$complete"
15598     arguments="EOL"
15599     new_path="$path"
15600 
15601   windows_path="$new_path"
15602   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15603     unix_path=`$CYGPATH -u "$windows_path"`
15604     new_path="$unix_path"
15605   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15606     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15607     new_path="$unix_path"
15608   fi
15609 
15610 
15611     new_path=`$WHICH "$new_path" 2> /dev/null`
15612     # bat and cmd files are not always considered executable in MSYS causing which
15613     # to not find them
15614     if test "x$new_path" = x \
15615         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15616         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15617       new_path="$path"
15618 
15619   windows_path="$new_path"
15620   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15621     unix_path=`$CYGPATH -u "$windows_path"`
15622     new_path="$unix_path"
15623   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15624     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15625     new_path="$unix_path"
15626   fi
15627 
15628     fi
15629 
15630     if test "x$new_path" = x; then
15631       # It's still not found. Now this is an unrecoverable error.
15632       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15633 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15634       has_space=`$ECHO "$complete" | $GREP " "`
15635       if test "x$has_space" != x; then
15636         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15637 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15638       fi
15639       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15640     fi
15641   fi
15642 
15643   # Now new_path has a complete unix path to the binary
15644   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15645     # Keep paths in /bin as-is, but remove trailing .exe if any
15646     new_path="${new_path/%.exe/}"
15647     # Do not save /bin paths to all_fixpath_prefixes!
15648   else
15649     # Not in mixed or Windows style, start by that.
15650     new_path=`cmd //c echo $new_path`
15651 
15652   input_path="$new_path"
15653   # Check if we need to convert this using DOS-style short mode. If the path
15654   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15655   # take no chances and rewrite it.
15656   # Note: m4 eats our [], so we need to use [ and ] instead.
15657   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15658   if test "x$has_forbidden_chars" != x; then
15659     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15660     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15661   fi
15662 
15663     # Output is in $new_path
15664 
15665   windows_path="$new_path"
15666   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15667     unix_path=`$CYGPATH -u "$windows_path"`
15668     new_path="$unix_path"
15669   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15670     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15671     new_path="$unix_path"
15672   fi
15673 
15674     # remove trailing .exe if any
15675     new_path="${new_path/%.exe/}"
15676 
15677     # Save the first 10 bytes of this path to the storage, so fixpath can work.
15678     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15679   fi
15680 
15681   else
15682     # We're on a posix platform. Hooray! :)
15683     # First separate the path from the arguments. This will split at the first
15684     # space.
15685     complete="$FOUND_MAKE"
15686     path="${complete%% *}"
15687     tmp="$complete EOL"
15688     arguments="${tmp#* }"
15689 
15690     # Cannot rely on the command "which" here since it doesn't always work.
15691     is_absolute_path=`$ECHO "$path" | $GREP ^/`
15692     if test -z "$is_absolute_path"; then
15693       # Path to executable is not absolute. Find it.
15694       IFS_save="$IFS"
15695       IFS=:
15696       for p in $PATH; do
15697         if test -f "$p/$path" && test -x "$p/$path"; then
15698           new_path="$p/$path"
15699           break
15700         fi
15701       done
15702       IFS="$IFS_save"
15703     else
15704       # This is an absolute path, we can use it without further modifications.
15705       new_path="$path"
15706     fi
15707 
15708     if test "x$new_path" = x; then
15709       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15710 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15711       has_space=`$ECHO "$complete" | $GREP " "`
15712       if test "x$has_space" != x; then
15713         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
15714 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
15715       fi
15716       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15717     fi
15718   fi
15719 
15720   # Now join together the path and the arguments once again
15721   if test "x$arguments" != xEOL; then
15722     new_complete="$new_path ${arguments% *}"
15723   else
15724     new_complete="$new_path"
15725   fi
15726 
15727   if test "x$complete" != "x$new_complete"; then
15728     FOUND_MAKE="$new_complete"
15729     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
15730 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
15731   fi
15732 
15733         fi
15734       fi
15735     fi
15736   fi
15737 
15738     if test "x$FOUND_MAKE" = x; then
15739       as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make 3.81 or newer." "$LINENO" 5
15740     fi
15741   else
15742     # Try our hardest to locate a correct version of GNU make
15743     for ac_prog in gmake
15744 do
15745   # Extract the first word of "$ac_prog", so it can be a program name with args.
15746 set dummy $ac_prog; ac_word=$2
15747 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15748 $as_echo_n "checking for $ac_word... " >&6; }
15749 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
15750   $as_echo_n "(cached) " >&6
15751 else
15752   case $CHECK_GMAKE in
15753   [\\/]* | ?:[\\/]*)
15754   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
15755   ;;
15756   *)
15757   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15758 for as_dir in $PATH
15759 do
15760   IFS=$as_save_IFS
15761   test -z "$as_dir" && as_dir=.
15762     for ac_exec_ext in '' $ac_executable_extensions; do
15763   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15764     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
15765     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15766     break 2
15767   fi
15768 done
15769   done
15770 IFS=$as_save_IFS
15771 
15772   ;;
15773 esac
15774 fi
15775 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
15776 if test -n "$CHECK_GMAKE"; then
15777   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
15778 $as_echo "$CHECK_GMAKE" >&6; }
15779 else
15780   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15781 $as_echo "no" >&6; }
15782 fi
15783 
15784 
15785   test -n "$CHECK_GMAKE" && break
15786 done
15787 
15788 
15789   MAKE_CANDIDATE=""$CHECK_GMAKE""
15790   DESCRIPTION="gmake in PATH"
15791   if test "x$MAKE_CANDIDATE" != x; then
15792     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15793 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15794     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15795     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15796     if test "x$IS_GNU_MAKE" = x; then
15797       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15798 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15799     else
15800       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15801       if test "x$IS_MODERN_MAKE" = x; then
15802         { $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
15803 $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;}
15804       else
15805         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15806           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15807             MAKE_EXPECTED_ENV='cygwin'
15808           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15809             MAKE_EXPECTED_ENV='msys'
15810           else
15811             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15812           fi
15813           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15814           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15815         else
15816           # Not relevant for non-Windows
15817           IS_MAKE_CORRECT_ENV=true
15818         fi
15819         if test "x$IS_MAKE_CORRECT_ENV" = x; then
15820           { $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
15821 $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;}
15822         else
15823           FOUND_MAKE=$MAKE_CANDIDATE
15824 
15825   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15826 
15827   # First separate the path from the arguments. This will split at the first
15828   # space.
15829   complete="$FOUND_MAKE"
15830   path="${complete%% *}"
15831   tmp="$complete EOL"
15832   arguments="${tmp#* }"
15833 
15834   # Input might be given as Windows format, start by converting to
15835   # unix format.
15836   new_path=`$CYGPATH -u "$path"`
15837 
15838   # Now try to locate executable using which
15839   new_path=`$WHICH "$new_path" 2> /dev/null`
15840   # bat and cmd files are not always considered executable in cygwin causing which
15841   # to not find them
15842   if test "x$new_path" = x \
15843       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15844       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15845     new_path=`$CYGPATH -u "$path"`
15846   fi
15847   if test "x$new_path" = x; then
15848     # Oops. Which didn't find the executable.
15849     # The splitting of arguments from the executable at a space might have been incorrect,
15850     # since paths with space are more likely in Windows. Give it another try with the whole
15851     # argument.
15852     path="$complete"
15853     arguments="EOL"
15854     new_path=`$CYGPATH -u "$path"`
15855     new_path=`$WHICH "$new_path" 2> /dev/null`
15856     # bat and cmd files are not always considered executable in cygwin causing which
15857     # to not find them
15858     if test "x$new_path" = x \
15859         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15860         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15861       new_path=`$CYGPATH -u "$path"`
15862     fi
15863     if test "x$new_path" = x; then
15864       # It's still not found. Now this is an unrecoverable error.
15865       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15866 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15867       has_space=`$ECHO "$complete" | $GREP " "`
15868       if test "x$has_space" != x; then
15869         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15870 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15871       fi
15872       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15873     fi
15874   fi
15875 
15876   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15877   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15878   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15879   # "foo.exe" is OK but "foo" is an error.
15880   #
15881   # This test is therefore slightly more accurate than "test -f" to check for file presence.
15882   # It is also a way to make sure we got the proper file name for the real test later on.
15883   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15884   if test "x$test_shortpath" = x; then
15885     # Short path failed, file does not exist as specified.
15886     # Try adding .exe or .cmd
15887     if test -f "${new_path}.exe"; then
15888       input_to_shortpath="${new_path}.exe"
15889     elif test -f "${new_path}.cmd"; then
15890       input_to_shortpath="${new_path}.cmd"
15891     else
15892       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15893 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15894       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15895 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15896       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15897     fi
15898   else
15899     input_to_shortpath="$new_path"
15900   fi
15901 
15902   # Call helper function which possibly converts this using DOS-style short mode.
15903   # If so, the updated path is stored in $new_path.
15904   new_path="$input_to_shortpath"
15905 
15906   input_path="$input_to_shortpath"
15907   # Check if we need to convert this using DOS-style short mode. If the path
15908   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15909   # take no chances and rewrite it.
15910   # Note: m4 eats our [], so we need to use [ and ] instead.
15911   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15912   if test "x$has_forbidden_chars" != x; then
15913     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15914     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15915     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15916     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15917       # Going to short mode and back again did indeed matter. Since short mode is
15918       # case insensitive, let's make it lowercase to improve readability.
15919       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15920       # Now convert it back to Unix-style (cygpath)
15921       input_path=`$CYGPATH -u "$shortmode_path"`
15922       new_path="$input_path"
15923     fi
15924   fi
15925 
15926   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15927   if test "x$test_cygdrive_prefix" = x; then
15928     # As a simple fix, exclude /usr/bin since it's not a real path.
15929     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15930       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15931       # a path prefixed by /cygdrive for fixpath to work.
15932       new_path="$CYGWIN_ROOT_PATH$input_path"
15933     fi
15934   fi
15935 
15936   # remove trailing .exe if any
15937   new_path="${new_path/%.exe/}"
15938 
15939   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15940 
15941   # First separate the path from the arguments. This will split at the first
15942   # space.
15943   complete="$FOUND_MAKE"
15944   path="${complete%% *}"
15945   tmp="$complete EOL"
15946   arguments="${tmp#* }"
15947 
15948   # Input might be given as Windows format, start by converting to
15949   # unix format.
15950   new_path="$path"
15951 
15952   windows_path="$new_path"
15953   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15954     unix_path=`$CYGPATH -u "$windows_path"`
15955     new_path="$unix_path"
15956   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15957     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15958     new_path="$unix_path"
15959   fi
15960 
15961 
15962   # Now try to locate executable using which
15963   new_path=`$WHICH "$new_path" 2> /dev/null`
15964 
15965   if test "x$new_path" = x; then
15966     # Oops. Which didn't find the executable.
15967     # The splitting of arguments from the executable at a space might have been incorrect,
15968     # since paths with space are more likely in Windows. Give it another try with the whole
15969     # argument.
15970     path="$complete"
15971     arguments="EOL"
15972     new_path="$path"
15973 
15974   windows_path="$new_path"
15975   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15976     unix_path=`$CYGPATH -u "$windows_path"`
15977     new_path="$unix_path"
15978   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15979     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15980     new_path="$unix_path"
15981   fi
15982 
15983 
15984     new_path=`$WHICH "$new_path" 2> /dev/null`
15985     # bat and cmd files are not always considered executable in MSYS causing which
15986     # to not find them
15987     if test "x$new_path" = x \
15988         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15989         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15990       new_path="$path"
15991 
15992   windows_path="$new_path"
15993   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15994     unix_path=`$CYGPATH -u "$windows_path"`
15995     new_path="$unix_path"
15996   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15997     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15998     new_path="$unix_path"
15999   fi
16000 
16001     fi
16002 
16003     if test "x$new_path" = x; then
16004       # It's still not found. Now this is an unrecoverable error.
16005       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16006 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16007       has_space=`$ECHO "$complete" | $GREP " "`
16008       if test "x$has_space" != x; then
16009         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16010 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16011       fi
16012       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16013     fi
16014   fi
16015 
16016   # Now new_path has a complete unix path to the binary
16017   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16018     # Keep paths in /bin as-is, but remove trailing .exe if any
16019     new_path="${new_path/%.exe/}"
16020     # Do not save /bin paths to all_fixpath_prefixes!
16021   else
16022     # Not in mixed or Windows style, start by that.
16023     new_path=`cmd //c echo $new_path`
16024 
16025   input_path="$new_path"
16026   # Check if we need to convert this using DOS-style short mode. If the path
16027   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16028   # take no chances and rewrite it.
16029   # Note: m4 eats our [], so we need to use [ and ] instead.
16030   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16031   if test "x$has_forbidden_chars" != x; then
16032     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16033     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16034   fi
16035 
16036     # Output is in $new_path
16037 
16038   windows_path="$new_path"
16039   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16040     unix_path=`$CYGPATH -u "$windows_path"`
16041     new_path="$unix_path"
16042   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16043     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16044     new_path="$unix_path"
16045   fi
16046 
16047     # remove trailing .exe if any
16048     new_path="${new_path/%.exe/}"
16049 
16050     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16051     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16052   fi
16053 
16054   else
16055     # We're on a posix platform. Hooray! :)
16056     # First separate the path from the arguments. This will split at the first
16057     # space.
16058     complete="$FOUND_MAKE"
16059     path="${complete%% *}"
16060     tmp="$complete EOL"
16061     arguments="${tmp#* }"
16062 
16063     # Cannot rely on the command "which" here since it doesn't always work.
16064     is_absolute_path=`$ECHO "$path" | $GREP ^/`
16065     if test -z "$is_absolute_path"; then
16066       # Path to executable is not absolute. Find it.
16067       IFS_save="$IFS"
16068       IFS=:
16069       for p in $PATH; do
16070         if test -f "$p/$path" && test -x "$p/$path"; then
16071           new_path="$p/$path"
16072           break
16073         fi
16074       done
16075       IFS="$IFS_save"
16076     else
16077       # This is an absolute path, we can use it without further modifications.
16078       new_path="$path"
16079     fi
16080 
16081     if test "x$new_path" = x; then
16082       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16083 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16084       has_space=`$ECHO "$complete" | $GREP " "`
16085       if test "x$has_space" != x; then
16086         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16087 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16088       fi
16089       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16090     fi
16091   fi
16092 
16093   # Now join together the path and the arguments once again
16094   if test "x$arguments" != xEOL; then
16095     new_complete="$new_path ${arguments% *}"
16096   else
16097     new_complete="$new_path"
16098   fi
16099 
16100   if test "x$complete" != "x$new_complete"; then
16101     FOUND_MAKE="$new_complete"
16102     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16103 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16104   fi
16105 
16106         fi
16107       fi
16108     fi
16109   fi
16110 
16111 
16112     if test "x$FOUND_MAKE" = x; then
16113       for ac_prog in make
16114 do
16115   # Extract the first word of "$ac_prog", so it can be a program name with args.
16116 set dummy $ac_prog; ac_word=$2
16117 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16118 $as_echo_n "checking for $ac_word... " >&6; }
16119 if ${ac_cv_path_CHECK_MAKE+:} false; then :
16120   $as_echo_n "(cached) " >&6
16121 else
16122   case $CHECK_MAKE in
16123   [\\/]* | ?:[\\/]*)
16124   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
16125   ;;
16126   *)
16127   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16128 for as_dir in $PATH
16129 do
16130   IFS=$as_save_IFS
16131   test -z "$as_dir" && as_dir=.
16132     for ac_exec_ext in '' $ac_executable_extensions; do
16133   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16134     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
16135     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16136     break 2
16137   fi
16138 done
16139   done
16140 IFS=$as_save_IFS
16141 
16142   ;;
16143 esac
16144 fi
16145 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
16146 if test -n "$CHECK_MAKE"; then
16147   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
16148 $as_echo "$CHECK_MAKE" >&6; }
16149 else
16150   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16151 $as_echo "no" >&6; }
16152 fi
16153 
16154 
16155   test -n "$CHECK_MAKE" && break
16156 done
16157 
16158 
16159   MAKE_CANDIDATE=""$CHECK_MAKE""
16160   DESCRIPTION="make in PATH"
16161   if test "x$MAKE_CANDIDATE" != x; then
16162     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16163 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16164     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16165     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16166     if test "x$IS_GNU_MAKE" = x; then
16167       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16168 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16169     else
16170       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
16171       if test "x$IS_MODERN_MAKE" = x; then
16172         { $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
16173 $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;}
16174       else
16175         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16176           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16177             MAKE_EXPECTED_ENV='cygwin'
16178           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16179             MAKE_EXPECTED_ENV='msys'
16180           else
16181             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16182           fi
16183           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16184           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16185         else
16186           # Not relevant for non-Windows
16187           IS_MAKE_CORRECT_ENV=true
16188         fi
16189         if test "x$IS_MAKE_CORRECT_ENV" = x; then
16190           { $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
16191 $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;}
16192         else
16193           FOUND_MAKE=$MAKE_CANDIDATE
16194 
16195   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16196 
16197   # First separate the path from the arguments. This will split at the first
16198   # space.
16199   complete="$FOUND_MAKE"
16200   path="${complete%% *}"
16201   tmp="$complete EOL"
16202   arguments="${tmp#* }"
16203 
16204   # Input might be given as Windows format, start by converting to
16205   # unix format.
16206   new_path=`$CYGPATH -u "$path"`
16207 
16208   # Now try to locate executable using which
16209   new_path=`$WHICH "$new_path" 2> /dev/null`
16210   # bat and cmd files are not always considered executable in cygwin causing which
16211   # to not find them
16212   if test "x$new_path" = x \
16213       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16214       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16215     new_path=`$CYGPATH -u "$path"`
16216   fi
16217   if test "x$new_path" = x; then
16218     # Oops. Which didn't find the executable.
16219     # The splitting of arguments from the executable at a space might have been incorrect,
16220     # since paths with space are more likely in Windows. Give it another try with the whole
16221     # argument.
16222     path="$complete"
16223     arguments="EOL"
16224     new_path=`$CYGPATH -u "$path"`
16225     new_path=`$WHICH "$new_path" 2> /dev/null`
16226     # bat and cmd files are not always considered executable in cygwin causing which
16227     # to not find them
16228     if test "x$new_path" = x \
16229         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16230         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16231       new_path=`$CYGPATH -u "$path"`
16232     fi
16233     if test "x$new_path" = x; then
16234       # It's still not found. Now this is an unrecoverable error.
16235       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16236 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16237       has_space=`$ECHO "$complete" | $GREP " "`
16238       if test "x$has_space" != x; then
16239         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16240 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16241       fi
16242       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16243     fi
16244   fi
16245 
16246   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16247   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16248   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16249   # "foo.exe" is OK but "foo" is an error.
16250   #
16251   # This test is therefore slightly more accurate than "test -f" to check for file presence.
16252   # It is also a way to make sure we got the proper file name for the real test later on.
16253   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16254   if test "x$test_shortpath" = x; then
16255     # Short path failed, file does not exist as specified.
16256     # Try adding .exe or .cmd
16257     if test -f "${new_path}.exe"; then
16258       input_to_shortpath="${new_path}.exe"
16259     elif test -f "${new_path}.cmd"; then
16260       input_to_shortpath="${new_path}.cmd"
16261     else
16262       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16263 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16264       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16265 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16266       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16267     fi
16268   else
16269     input_to_shortpath="$new_path"
16270   fi
16271 
16272   # Call helper function which possibly converts this using DOS-style short mode.
16273   # If so, the updated path is stored in $new_path.
16274   new_path="$input_to_shortpath"
16275 
16276   input_path="$input_to_shortpath"
16277   # Check if we need to convert this using DOS-style short mode. If the path
16278   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16279   # take no chances and rewrite it.
16280   # Note: m4 eats our [], so we need to use [ and ] instead.
16281   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16282   if test "x$has_forbidden_chars" != x; then
16283     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16284     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16285     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16286     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16287       # Going to short mode and back again did indeed matter. Since short mode is
16288       # case insensitive, let's make it lowercase to improve readability.
16289       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16290       # Now convert it back to Unix-style (cygpath)
16291       input_path=`$CYGPATH -u "$shortmode_path"`
16292       new_path="$input_path"
16293     fi
16294   fi
16295 
16296   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16297   if test "x$test_cygdrive_prefix" = x; then
16298     # As a simple fix, exclude /usr/bin since it's not a real path.
16299     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16300       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16301       # a path prefixed by /cygdrive for fixpath to work.
16302       new_path="$CYGWIN_ROOT_PATH$input_path"
16303     fi
16304   fi
16305 
16306   # remove trailing .exe if any
16307   new_path="${new_path/%.exe/}"
16308 
16309   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16310 
16311   # First separate the path from the arguments. This will split at the first
16312   # space.
16313   complete="$FOUND_MAKE"
16314   path="${complete%% *}"
16315   tmp="$complete EOL"
16316   arguments="${tmp#* }"
16317 
16318   # Input might be given as Windows format, start by converting to
16319   # unix format.
16320   new_path="$path"
16321 
16322   windows_path="$new_path"
16323   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16324     unix_path=`$CYGPATH -u "$windows_path"`
16325     new_path="$unix_path"
16326   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16327     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16328     new_path="$unix_path"
16329   fi
16330 
16331 
16332   # Now try to locate executable using which
16333   new_path=`$WHICH "$new_path" 2> /dev/null`
16334 
16335   if test "x$new_path" = x; then
16336     # Oops. Which didn't find the executable.
16337     # The splitting of arguments from the executable at a space might have been incorrect,
16338     # since paths with space are more likely in Windows. Give it another try with the whole
16339     # argument.
16340     path="$complete"
16341     arguments="EOL"
16342     new_path="$path"
16343 
16344   windows_path="$new_path"
16345   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16346     unix_path=`$CYGPATH -u "$windows_path"`
16347     new_path="$unix_path"
16348   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16349     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16350     new_path="$unix_path"
16351   fi
16352 
16353 
16354     new_path=`$WHICH "$new_path" 2> /dev/null`
16355     # bat and cmd files are not always considered executable in MSYS causing which
16356     # to not find them
16357     if test "x$new_path" = x \
16358         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16359         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16360       new_path="$path"
16361 
16362   windows_path="$new_path"
16363   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16364     unix_path=`$CYGPATH -u "$windows_path"`
16365     new_path="$unix_path"
16366   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16367     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16368     new_path="$unix_path"
16369   fi
16370 
16371     fi
16372 
16373     if test "x$new_path" = x; then
16374       # It's still not found. Now this is an unrecoverable error.
16375       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16376 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16377       has_space=`$ECHO "$complete" | $GREP " "`
16378       if test "x$has_space" != x; then
16379         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16380 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16381       fi
16382       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16383     fi
16384   fi
16385 
16386   # Now new_path has a complete unix path to the binary
16387   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16388     # Keep paths in /bin as-is, but remove trailing .exe if any
16389     new_path="${new_path/%.exe/}"
16390     # Do not save /bin paths to all_fixpath_prefixes!
16391   else
16392     # Not in mixed or Windows style, start by that.
16393     new_path=`cmd //c echo $new_path`
16394 
16395   input_path="$new_path"
16396   # Check if we need to convert this using DOS-style short mode. If the path
16397   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16398   # take no chances and rewrite it.
16399   # Note: m4 eats our [], so we need to use [ and ] instead.
16400   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16401   if test "x$has_forbidden_chars" != x; then
16402     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16403     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16404   fi
16405 
16406     # Output is in $new_path
16407 
16408   windows_path="$new_path"
16409   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16410     unix_path=`$CYGPATH -u "$windows_path"`
16411     new_path="$unix_path"
16412   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16413     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16414     new_path="$unix_path"
16415   fi
16416 
16417     # remove trailing .exe if any
16418     new_path="${new_path/%.exe/}"
16419 
16420     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16421     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16422   fi
16423 
16424   else
16425     # We're on a posix platform. Hooray! :)
16426     # First separate the path from the arguments. This will split at the first
16427     # space.
16428     complete="$FOUND_MAKE"
16429     path="${complete%% *}"
16430     tmp="$complete EOL"
16431     arguments="${tmp#* }"
16432 
16433     # Cannot rely on the command "which" here since it doesn't always work.
16434     is_absolute_path=`$ECHO "$path" | $GREP ^/`
16435     if test -z "$is_absolute_path"; then
16436       # Path to executable is not absolute. Find it.
16437       IFS_save="$IFS"
16438       IFS=:
16439       for p in $PATH; do
16440         if test -f "$p/$path" && test -x "$p/$path"; then
16441           new_path="$p/$path"
16442           break
16443         fi
16444       done
16445       IFS="$IFS_save"
16446     else
16447       # This is an absolute path, we can use it without further modifications.
16448       new_path="$path"
16449     fi
16450 
16451     if test "x$new_path" = x; then
16452       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16453 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16454       has_space=`$ECHO "$complete" | $GREP " "`
16455       if test "x$has_space" != x; then
16456         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16457 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16458       fi
16459       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16460     fi
16461   fi
16462 
16463   # Now join together the path and the arguments once again
16464   if test "x$arguments" != xEOL; then
16465     new_complete="$new_path ${arguments% *}"
16466   else
16467     new_complete="$new_path"
16468   fi
16469 
16470   if test "x$complete" != "x$new_complete"; then
16471     FOUND_MAKE="$new_complete"
16472     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16473 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16474   fi
16475 
16476         fi
16477       fi
16478     fi
16479   fi
16480 
16481     fi
16482 
16483     if test "x$FOUND_MAKE" = x; then
16484       if test "x$TOOLCHAIN_PATH" != x; then
16485         # We have a toolchain path, check that as well before giving up.
16486         OLD_PATH=$PATH
16487         PATH=$TOOLCHAIN_PATH:$PATH
16488         for ac_prog in gmake
16489 do
16490   # Extract the first word of "$ac_prog", so it can be a program name with args.
16491 set dummy $ac_prog; ac_word=$2
16492 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16493 $as_echo_n "checking for $ac_word... " >&6; }
16494 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
16495   $as_echo_n "(cached) " >&6
16496 else
16497   case $CHECK_TOOLSDIR_GMAKE in
16498   [\\/]* | ?:[\\/]*)
16499   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
16500   ;;
16501   *)
16502   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16503 for as_dir in $PATH
16504 do
16505   IFS=$as_save_IFS
16506   test -z "$as_dir" && as_dir=.
16507     for ac_exec_ext in '' $ac_executable_extensions; do
16508   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16509     ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
16510     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16511     break 2
16512   fi
16513 done
16514   done
16515 IFS=$as_save_IFS
16516 
16517   ;;
16518 esac
16519 fi
16520 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
16521 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
16522   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
16523 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
16524 else
16525   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16526 $as_echo "no" >&6; }
16527 fi
16528 
16529 
16530   test -n "$CHECK_TOOLSDIR_GMAKE" && break
16531 done
16532 
16533 
16534   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
16535   DESCRIPTION="gmake in tools-dir"
16536   if test "x$MAKE_CANDIDATE" != x; then
16537     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16538 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16539     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16540     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16541     if test "x$IS_GNU_MAKE" = x; then
16542       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16543 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16544     else
16545       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
16546       if test "x$IS_MODERN_MAKE" = x; then
16547         { $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
16548 $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;}
16549       else
16550         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16551           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16552             MAKE_EXPECTED_ENV='cygwin'
16553           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16554             MAKE_EXPECTED_ENV='msys'
16555           else
16556             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16557           fi
16558           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16559           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16560         else
16561           # Not relevant for non-Windows
16562           IS_MAKE_CORRECT_ENV=true
16563         fi
16564         if test "x$IS_MAKE_CORRECT_ENV" = x; then
16565           { $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
16566 $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;}
16567         else
16568           FOUND_MAKE=$MAKE_CANDIDATE
16569 
16570   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16571 
16572   # First separate the path from the arguments. This will split at the first
16573   # space.
16574   complete="$FOUND_MAKE"
16575   path="${complete%% *}"
16576   tmp="$complete EOL"
16577   arguments="${tmp#* }"
16578 
16579   # Input might be given as Windows format, start by converting to
16580   # unix format.
16581   new_path=`$CYGPATH -u "$path"`
16582 
16583   # Now try to locate executable using which
16584   new_path=`$WHICH "$new_path" 2> /dev/null`
16585   # bat and cmd files are not always considered executable in cygwin causing which
16586   # to not find them
16587   if test "x$new_path" = x \
16588       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16589       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16590     new_path=`$CYGPATH -u "$path"`
16591   fi
16592   if test "x$new_path" = x; then
16593     # Oops. Which didn't find the executable.
16594     # The splitting of arguments from the executable at a space might have been incorrect,
16595     # since paths with space are more likely in Windows. Give it another try with the whole
16596     # argument.
16597     path="$complete"
16598     arguments="EOL"
16599     new_path=`$CYGPATH -u "$path"`
16600     new_path=`$WHICH "$new_path" 2> /dev/null`
16601     # bat and cmd files are not always considered executable in cygwin causing which
16602     # to not find them
16603     if test "x$new_path" = x \
16604         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16605         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16606       new_path=`$CYGPATH -u "$path"`
16607     fi
16608     if test "x$new_path" = x; then
16609       # It's still not found. Now this is an unrecoverable error.
16610       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16611 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16612       has_space=`$ECHO "$complete" | $GREP " "`
16613       if test "x$has_space" != x; then
16614         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16615 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16616       fi
16617       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16618     fi
16619   fi
16620 
16621   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16622   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16623   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16624   # "foo.exe" is OK but "foo" is an error.
16625   #
16626   # This test is therefore slightly more accurate than "test -f" to check for file presence.
16627   # It is also a way to make sure we got the proper file name for the real test later on.
16628   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16629   if test "x$test_shortpath" = x; then
16630     # Short path failed, file does not exist as specified.
16631     # Try adding .exe or .cmd
16632     if test -f "${new_path}.exe"; then
16633       input_to_shortpath="${new_path}.exe"
16634     elif test -f "${new_path}.cmd"; then
16635       input_to_shortpath="${new_path}.cmd"
16636     else
16637       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16638 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16639       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16640 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16641       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16642     fi
16643   else
16644     input_to_shortpath="$new_path"
16645   fi
16646 
16647   # Call helper function which possibly converts this using DOS-style short mode.
16648   # If so, the updated path is stored in $new_path.
16649   new_path="$input_to_shortpath"
16650 
16651   input_path="$input_to_shortpath"
16652   # Check if we need to convert this using DOS-style short mode. If the path
16653   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16654   # take no chances and rewrite it.
16655   # Note: m4 eats our [], so we need to use [ and ] instead.
16656   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16657   if test "x$has_forbidden_chars" != x; then
16658     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16659     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16660     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16661     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16662       # Going to short mode and back again did indeed matter. Since short mode is
16663       # case insensitive, let's make it lowercase to improve readability.
16664       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16665       # Now convert it back to Unix-style (cygpath)
16666       input_path=`$CYGPATH -u "$shortmode_path"`
16667       new_path="$input_path"
16668     fi
16669   fi
16670 
16671   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16672   if test "x$test_cygdrive_prefix" = x; then
16673     # As a simple fix, exclude /usr/bin since it's not a real path.
16674     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16675       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16676       # a path prefixed by /cygdrive for fixpath to work.
16677       new_path="$CYGWIN_ROOT_PATH$input_path"
16678     fi
16679   fi
16680 
16681   # remove trailing .exe if any
16682   new_path="${new_path/%.exe/}"
16683 
16684   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16685 
16686   # First separate the path from the arguments. This will split at the first
16687   # space.
16688   complete="$FOUND_MAKE"
16689   path="${complete%% *}"
16690   tmp="$complete EOL"
16691   arguments="${tmp#* }"
16692 
16693   # Input might be given as Windows format, start by converting to
16694   # unix format.
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   # Now try to locate executable using which
16708   new_path=`$WHICH "$new_path" 2> /dev/null`
16709 
16710   if test "x$new_path" = x; then
16711     # Oops. Which didn't find the executable.
16712     # The splitting of arguments from the executable at a space might have been incorrect,
16713     # since paths with space are more likely in Windows. Give it another try with the whole
16714     # argument.
16715     path="$complete"
16716     arguments="EOL"
16717     new_path="$path"
16718 
16719   windows_path="$new_path"
16720   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16721     unix_path=`$CYGPATH -u "$windows_path"`
16722     new_path="$unix_path"
16723   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16724     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16725     new_path="$unix_path"
16726   fi
16727 
16728 
16729     new_path=`$WHICH "$new_path" 2> /dev/null`
16730     # bat and cmd files are not always considered executable in MSYS causing which
16731     # to not find them
16732     if test "x$new_path" = x \
16733         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16734         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16735       new_path="$path"
16736 
16737   windows_path="$new_path"
16738   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16739     unix_path=`$CYGPATH -u "$windows_path"`
16740     new_path="$unix_path"
16741   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16742     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16743     new_path="$unix_path"
16744   fi
16745 
16746     fi
16747 
16748     if test "x$new_path" = x; then
16749       # It's still not found. Now this is an unrecoverable error.
16750       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16751 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16752       has_space=`$ECHO "$complete" | $GREP " "`
16753       if test "x$has_space" != x; then
16754         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16755 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16756       fi
16757       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16758     fi
16759   fi
16760 
16761   # Now new_path has a complete unix path to the binary
16762   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16763     # Keep paths in /bin as-is, but remove trailing .exe if any
16764     new_path="${new_path/%.exe/}"
16765     # Do not save /bin paths to all_fixpath_prefixes!
16766   else
16767     # Not in mixed or Windows style, start by that.
16768     new_path=`cmd //c echo $new_path`
16769 
16770   input_path="$new_path"
16771   # Check if we need to convert this using DOS-style short mode. If the path
16772   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16773   # take no chances and rewrite it.
16774   # Note: m4 eats our [], so we need to use [ and ] instead.
16775   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16776   if test "x$has_forbidden_chars" != x; then
16777     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16778     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16779   fi
16780 
16781     # Output is in $new_path
16782 
16783   windows_path="$new_path"
16784   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16785     unix_path=`$CYGPATH -u "$windows_path"`
16786     new_path="$unix_path"
16787   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16788     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16789     new_path="$unix_path"
16790   fi
16791 
16792     # remove trailing .exe if any
16793     new_path="${new_path/%.exe/}"
16794 
16795     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16796     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16797   fi
16798 
16799   else
16800     # We're on a posix platform. Hooray! :)
16801     # First separate the path from the arguments. This will split at the first
16802     # space.
16803     complete="$FOUND_MAKE"
16804     path="${complete%% *}"
16805     tmp="$complete EOL"
16806     arguments="${tmp#* }"
16807 
16808     # Cannot rely on the command "which" here since it doesn't always work.
16809     is_absolute_path=`$ECHO "$path" | $GREP ^/`
16810     if test -z "$is_absolute_path"; then
16811       # Path to executable is not absolute. Find it.
16812       IFS_save="$IFS"
16813       IFS=:
16814       for p in $PATH; do
16815         if test -f "$p/$path" && test -x "$p/$path"; then
16816           new_path="$p/$path"
16817           break
16818         fi
16819       done
16820       IFS="$IFS_save"
16821     else
16822       # This is an absolute path, we can use it without further modifications.
16823       new_path="$path"
16824     fi
16825 
16826     if test "x$new_path" = x; then
16827       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16828 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16829       has_space=`$ECHO "$complete" | $GREP " "`
16830       if test "x$has_space" != x; then
16831         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16832 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16833       fi
16834       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16835     fi
16836   fi
16837 
16838   # Now join together the path and the arguments once again
16839   if test "x$arguments" != xEOL; then
16840     new_complete="$new_path ${arguments% *}"
16841   else
16842     new_complete="$new_path"
16843   fi
16844 
16845   if test "x$complete" != "x$new_complete"; then
16846     FOUND_MAKE="$new_complete"
16847     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16848 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16849   fi
16850 
16851         fi
16852       fi
16853     fi
16854   fi
16855 
16856         if test "x$FOUND_MAKE" = x; then
16857           for ac_prog in make
16858 do
16859   # Extract the first word of "$ac_prog", so it can be a program name with args.
16860 set dummy $ac_prog; ac_word=$2
16861 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16862 $as_echo_n "checking for $ac_word... " >&6; }
16863 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
16864   $as_echo_n "(cached) " >&6
16865 else
16866   case $CHECK_TOOLSDIR_MAKE in
16867   [\\/]* | ?:[\\/]*)
16868   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
16869   ;;
16870   *)
16871   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16872 for as_dir in $PATH
16873 do
16874   IFS=$as_save_IFS
16875   test -z "$as_dir" && as_dir=.
16876     for ac_exec_ext in '' $ac_executable_extensions; do
16877   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16878     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
16879     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16880     break 2
16881   fi
16882 done
16883   done
16884 IFS=$as_save_IFS
16885 
16886   ;;
16887 esac
16888 fi
16889 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
16890 if test -n "$CHECK_TOOLSDIR_MAKE"; then
16891   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
16892 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
16893 else
16894   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16895 $as_echo "no" >&6; }
16896 fi
16897 
16898 
16899   test -n "$CHECK_TOOLSDIR_MAKE" && break
16900 done
16901 
16902 
16903   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
16904   DESCRIPTION="make in tools-dir"
16905   if test "x$MAKE_CANDIDATE" != x; then
16906     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16907 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16908     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16909     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16910     if test "x$IS_GNU_MAKE" = x; then
16911       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16912 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16913     else
16914       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
16915       if test "x$IS_MODERN_MAKE" = x; then
16916         { $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
16917 $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;}
16918       else
16919         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16920           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16921             MAKE_EXPECTED_ENV='cygwin'
16922           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16923             MAKE_EXPECTED_ENV='msys'
16924           else
16925             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16926           fi
16927           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16928           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16929         else
16930           # Not relevant for non-Windows
16931           IS_MAKE_CORRECT_ENV=true
16932         fi
16933         if test "x$IS_MAKE_CORRECT_ENV" = x; then
16934           { $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
16935 $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;}
16936         else
16937           FOUND_MAKE=$MAKE_CANDIDATE
16938 
16939   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16940 
16941   # First separate the path from the arguments. This will split at the first
16942   # space.
16943   complete="$FOUND_MAKE"
16944   path="${complete%% *}"
16945   tmp="$complete EOL"
16946   arguments="${tmp#* }"
16947 
16948   # Input might be given as Windows format, start by converting to
16949   # unix format.
16950   new_path=`$CYGPATH -u "$path"`
16951 
16952   # Now try to locate executable using which
16953   new_path=`$WHICH "$new_path" 2> /dev/null`
16954   # bat and cmd files are not always considered executable in cygwin causing which
16955   # to not find them
16956   if test "x$new_path" = x \
16957       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16958       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16959     new_path=`$CYGPATH -u "$path"`
16960   fi
16961   if test "x$new_path" = x; then
16962     # Oops. Which didn't find the executable.
16963     # The splitting of arguments from the executable at a space might have been incorrect,
16964     # since paths with space are more likely in Windows. Give it another try with the whole
16965     # argument.
16966     path="$complete"
16967     arguments="EOL"
16968     new_path=`$CYGPATH -u "$path"`
16969     new_path=`$WHICH "$new_path" 2> /dev/null`
16970     # bat and cmd files are not always considered executable in cygwin causing which
16971     # to not find them
16972     if test "x$new_path" = x \
16973         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16974         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16975       new_path=`$CYGPATH -u "$path"`
16976     fi
16977     if test "x$new_path" = x; then
16978       # It's still not found. Now this is an unrecoverable error.
16979       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16980 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16981       has_space=`$ECHO "$complete" | $GREP " "`
16982       if test "x$has_space" != x; then
16983         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16984 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16985       fi
16986       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16987     fi
16988   fi
16989 
16990   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16991   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16992   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16993   # "foo.exe" is OK but "foo" is an error.
16994   #
16995   # This test is therefore slightly more accurate than "test -f" to check for file presence.
16996   # It is also a way to make sure we got the proper file name for the real test later on.
16997   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16998   if test "x$test_shortpath" = x; then
16999     # Short path failed, file does not exist as specified.
17000     # Try adding .exe or .cmd
17001     if test -f "${new_path}.exe"; then
17002       input_to_shortpath="${new_path}.exe"
17003     elif test -f "${new_path}.cmd"; then
17004       input_to_shortpath="${new_path}.cmd"
17005     else
17006       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17007 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17008       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17009 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17010       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17011     fi
17012   else
17013     input_to_shortpath="$new_path"
17014   fi
17015 
17016   # Call helper function which possibly converts this using DOS-style short mode.
17017   # If so, the updated path is stored in $new_path.
17018   new_path="$input_to_shortpath"
17019 
17020   input_path="$input_to_shortpath"
17021   # Check if we need to convert this using DOS-style short mode. If the path
17022   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17023   # take no chances and rewrite it.
17024   # Note: m4 eats our [], so we need to use [ and ] instead.
17025   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17026   if test "x$has_forbidden_chars" != x; then
17027     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17028     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17029     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17030     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17031       # Going to short mode and back again did indeed matter. Since short mode is
17032       # case insensitive, let's make it lowercase to improve readability.
17033       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17034       # Now convert it back to Unix-style (cygpath)
17035       input_path=`$CYGPATH -u "$shortmode_path"`
17036       new_path="$input_path"
17037     fi
17038   fi
17039 
17040   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17041   if test "x$test_cygdrive_prefix" = x; then
17042     # As a simple fix, exclude /usr/bin since it's not a real path.
17043     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17044       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17045       # a path prefixed by /cygdrive for fixpath to work.
17046       new_path="$CYGWIN_ROOT_PATH$input_path"
17047     fi
17048   fi
17049 
17050   # remove trailing .exe if any
17051   new_path="${new_path/%.exe/}"
17052 
17053   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17054 
17055   # First separate the path from the arguments. This will split at the first
17056   # space.
17057   complete="$FOUND_MAKE"
17058   path="${complete%% *}"
17059   tmp="$complete EOL"
17060   arguments="${tmp#* }"
17061 
17062   # Input might be given as Windows format, start by converting to
17063   # unix format.
17064   new_path="$path"
17065 
17066   windows_path="$new_path"
17067   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17068     unix_path=`$CYGPATH -u "$windows_path"`
17069     new_path="$unix_path"
17070   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17071     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17072     new_path="$unix_path"
17073   fi
17074 
17075 
17076   # Now try to locate executable using which
17077   new_path=`$WHICH "$new_path" 2> /dev/null`
17078 
17079   if test "x$new_path" = x; then
17080     # Oops. Which didn't find the executable.
17081     # The splitting of arguments from the executable at a space might have been incorrect,
17082     # since paths with space are more likely in Windows. Give it another try with the whole
17083     # argument.
17084     path="$complete"
17085     arguments="EOL"
17086     new_path="$path"
17087 
17088   windows_path="$new_path"
17089   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17090     unix_path=`$CYGPATH -u "$windows_path"`
17091     new_path="$unix_path"
17092   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17093     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17094     new_path="$unix_path"
17095   fi
17096 
17097 
17098     new_path=`$WHICH "$new_path" 2> /dev/null`
17099     # bat and cmd files are not always considered executable in MSYS causing which
17100     # to not find them
17101     if test "x$new_path" = x \
17102         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17103         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17104       new_path="$path"
17105 
17106   windows_path="$new_path"
17107   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17108     unix_path=`$CYGPATH -u "$windows_path"`
17109     new_path="$unix_path"
17110   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17111     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17112     new_path="$unix_path"
17113   fi
17114 
17115     fi
17116 
17117     if test "x$new_path" = x; then
17118       # It's still not found. Now this is an unrecoverable error.
17119       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17120 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17121       has_space=`$ECHO "$complete" | $GREP " "`
17122       if test "x$has_space" != x; then
17123         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17124 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17125       fi
17126       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17127     fi
17128   fi
17129 
17130   # Now new_path has a complete unix path to the binary
17131   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17132     # Keep paths in /bin as-is, but remove trailing .exe if any
17133     new_path="${new_path/%.exe/}"
17134     # Do not save /bin paths to all_fixpath_prefixes!
17135   else
17136     # Not in mixed or Windows style, start by that.
17137     new_path=`cmd //c echo $new_path`
17138 
17139   input_path="$new_path"
17140   # Check if we need to convert this using DOS-style short mode. If the path
17141   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17142   # take no chances and rewrite it.
17143   # Note: m4 eats our [], so we need to use [ and ] instead.
17144   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17145   if test "x$has_forbidden_chars" != x; then
17146     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17147     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17148   fi
17149 
17150     # Output is in $new_path
17151 
17152   windows_path="$new_path"
17153   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17154     unix_path=`$CYGPATH -u "$windows_path"`
17155     new_path="$unix_path"
17156   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17157     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17158     new_path="$unix_path"
17159   fi
17160 
17161     # remove trailing .exe if any
17162     new_path="${new_path/%.exe/}"
17163 
17164     # Save the first 10 bytes of this path to the storage, so fixpath can work.
17165     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17166   fi
17167 
17168   else
17169     # We're on a posix platform. Hooray! :)
17170     # First separate the path from the arguments. This will split at the first
17171     # space.
17172     complete="$FOUND_MAKE"
17173     path="${complete%% *}"
17174     tmp="$complete EOL"
17175     arguments="${tmp#* }"
17176 
17177     # Cannot rely on the command "which" here since it doesn't always work.
17178     is_absolute_path=`$ECHO "$path" | $GREP ^/`
17179     if test -z "$is_absolute_path"; then
17180       # Path to executable is not absolute. Find it.
17181       IFS_save="$IFS"
17182       IFS=:
17183       for p in $PATH; do
17184         if test -f "$p/$path" && test -x "$p/$path"; then
17185           new_path="$p/$path"
17186           break
17187         fi
17188       done
17189       IFS="$IFS_save"
17190     else
17191       # This is an absolute path, we can use it without further modifications.
17192       new_path="$path"
17193     fi
17194 
17195     if test "x$new_path" = x; then
17196       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17197 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17198       has_space=`$ECHO "$complete" | $GREP " "`
17199       if test "x$has_space" != x; then
17200         { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17201 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17202       fi
17203       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17204     fi
17205   fi
17206 
17207   # Now join together the path and the arguments once again
17208   if test "x$arguments" != xEOL; then
17209     new_complete="$new_path ${arguments% *}"
17210   else
17211     new_complete="$new_path"
17212   fi
17213 
17214   if test "x$complete" != "x$new_complete"; then
17215     FOUND_MAKE="$new_complete"
17216     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17217 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17218   fi
17219 
17220         fi
17221       fi
17222     fi
17223   fi
17224 
17225         fi
17226         PATH=$OLD_PATH
17227       fi
17228     fi
17229 
17230     if test "x$FOUND_MAKE" = x; then
17231       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
17232     fi
17233   fi
17234 
17235   MAKE=$FOUND_MAKE
17236 
17237   { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
17238 $as_echo "$as_me: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
17239 
17240 
17241 
17242   # Test if find supports -delete
17243   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
17244 $as_echo_n "checking if find supports -delete... " >&6; }
17245   FIND_DELETE="-delete"
17246 
17247   DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
17248 
17249   echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
17250 
17251   TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
17252   if test -f $DELETEDIR/TestIfFindSupportsDelete; then
17253     # No, it does not.
17254     rm $DELETEDIR/TestIfFindSupportsDelete
17255     FIND_DELETE="-exec rm \{\} \+"
17256     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17257 $as_echo "no" >&6; }
17258   else
17259     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
17260 $as_echo "yes" >&6; }
17261   fi
17262   rmdir $DELETEDIR
17263 
17264 
17265 
17266   # These tools might not be installed by default,
17267   # need hint on how to install them.
17268 
17269 
17270 
17271   # Publish this variable in the help.
17272 
17273 
17274   if test "x$UNZIP" = x; then
17275     # The variable is not set by user, try to locate tool using the code snippet
17276     for ac_prog in unzip
17277 do
17278   # Extract the first word of "$ac_prog", so it can be a program name with args.
17279 set dummy $ac_prog; ac_word=$2
17280 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17281 $as_echo_n "checking for $ac_word... " >&6; }
17282 if ${ac_cv_path_UNZIP+:} false; then :
17283   $as_echo_n "(cached) " >&6
17284 else
17285   case $UNZIP in
17286   [\\/]* | ?:[\\/]*)
17287   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17288   ;;
17289   *)
17290   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17291 for as_dir in $PATH
17292 do
17293   IFS=$as_save_IFS
17294   test -z "$as_dir" && as_dir=.
17295     for ac_exec_ext in '' $ac_executable_extensions; do
17296   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17297     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17298     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17299     break 2
17300   fi
17301 done
17302   done
17303 IFS=$as_save_IFS
17304 
17305   ;;
17306 esac
17307 fi
17308 UNZIP=$ac_cv_path_UNZIP
17309 if test -n "$UNZIP"; then
17310   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17311 $as_echo "$UNZIP" >&6; }
17312 else
17313   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17314 $as_echo "no" >&6; }
17315 fi
17316 
17317 
17318   test -n "$UNZIP" && break
17319 done
17320 
17321   else
17322     # The variable is set, but is it from the command line or the environment?
17323 
17324     # Try to remove the string !UNZIP! from our list.
17325     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
17326     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17327       # If it failed, the variable was not from the command line. Ignore it,
17328       # but warn the user (except for BASH, which is always set by the calling BASH).
17329       if test "xUNZIP" != xBASH; then
17330         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
17331 $as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
17332       fi
17333       # Try to locate tool using the code snippet
17334       for ac_prog in unzip
17335 do
17336   # Extract the first word of "$ac_prog", so it can be a program name with args.
17337 set dummy $ac_prog; ac_word=$2
17338 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17339 $as_echo_n "checking for $ac_word... " >&6; }
17340 if ${ac_cv_path_UNZIP+:} false; then :
17341   $as_echo_n "(cached) " >&6
17342 else
17343   case $UNZIP in
17344   [\\/]* | ?:[\\/]*)
17345   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17346   ;;
17347   *)
17348   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17349 for as_dir in $PATH
17350 do
17351   IFS=$as_save_IFS
17352   test -z "$as_dir" && as_dir=.
17353     for ac_exec_ext in '' $ac_executable_extensions; do
17354   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17355     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17356     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17357     break 2
17358   fi
17359 done
17360   done
17361 IFS=$as_save_IFS
17362 
17363   ;;
17364 esac
17365 fi
17366 UNZIP=$ac_cv_path_UNZIP
17367 if test -n "$UNZIP"; then
17368   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17369 $as_echo "$UNZIP" >&6; }
17370 else
17371   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17372 $as_echo "no" >&6; }
17373 fi
17374 
17375 
17376   test -n "$UNZIP" && break
17377 done
17378 
17379     else
17380       # If it succeeded, then it was overridden by the user. We will use it
17381       # for the tool.
17382 
17383       # First remove it from the list of overridden variables, so we can test
17384       # for unknown variables in the end.
17385       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17386 
17387       # Check if the provided tool contains a complete path.
17388       tool_specified="$UNZIP"
17389       tool_basename="${tool_specified##*/}"
17390       if test "x$tool_basename" = "x$tool_specified"; then
17391         # A command without a complete path is provided, search $PATH.
17392         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
17393 $as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
17394         # Extract the first word of "$tool_basename", so it can be a program name with args.
17395 set dummy $tool_basename; ac_word=$2
17396 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17397 $as_echo_n "checking for $ac_word... " >&6; }
17398 if ${ac_cv_path_UNZIP+:} false; then :
17399   $as_echo_n "(cached) " >&6
17400 else
17401   case $UNZIP in
17402   [\\/]* | ?:[\\/]*)
17403   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17404   ;;
17405   *)
17406   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17407 for as_dir in $PATH
17408 do
17409   IFS=$as_save_IFS
17410   test -z "$as_dir" && as_dir=.
17411     for ac_exec_ext in '' $ac_executable_extensions; do
17412   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17413     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17414     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17415     break 2
17416   fi
17417 done
17418   done
17419 IFS=$as_save_IFS
17420 
17421   ;;
17422 esac
17423 fi
17424 UNZIP=$ac_cv_path_UNZIP
17425 if test -n "$UNZIP"; then
17426   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17427 $as_echo "$UNZIP" >&6; }
17428 else
17429   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17430 $as_echo "no" >&6; }
17431 fi
17432 
17433 
17434         if test "x$UNZIP" = x; then
17435           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17436         fi
17437       else
17438         # Otherwise we believe it is a complete path. Use it as it is.
17439         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
17440 $as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
17441         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
17442 $as_echo_n "checking for UNZIP... " >&6; }
17443         if test ! -x "$tool_specified"; then
17444           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17445 $as_echo "not found" >&6; }
17446           as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17447         fi
17448         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17449 $as_echo "$tool_specified" >&6; }
17450       fi
17451     fi
17452   fi
17453 
17454 
17455 
17456   if test "x$UNZIP" = x; then
17457     as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
17458   fi
17459 
17460 
17461 
17462 
17463 
17464   # Publish this variable in the help.
17465 
17466 
17467   if test "x$ZIP" = x; then
17468     # The variable is not set by user, try to locate tool using the code snippet
17469     for ac_prog in zip
17470 do
17471   # Extract the first word of "$ac_prog", so it can be a program name with args.
17472 set dummy $ac_prog; ac_word=$2
17473 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17474 $as_echo_n "checking for $ac_word... " >&6; }
17475 if ${ac_cv_path_ZIP+:} false; then :
17476   $as_echo_n "(cached) " >&6
17477 else
17478   case $ZIP in
17479   [\\/]* | ?:[\\/]*)
17480   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17481   ;;
17482   *)
17483   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17484 for as_dir in $PATH
17485 do
17486   IFS=$as_save_IFS
17487   test -z "$as_dir" && as_dir=.
17488     for ac_exec_ext in '' $ac_executable_extensions; do
17489   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17490     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17491     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17492     break 2
17493   fi
17494 done
17495   done
17496 IFS=$as_save_IFS
17497 
17498   ;;
17499 esac
17500 fi
17501 ZIP=$ac_cv_path_ZIP
17502 if test -n "$ZIP"; then
17503   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17504 $as_echo "$ZIP" >&6; }
17505 else
17506   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17507 $as_echo "no" >&6; }
17508 fi
17509 
17510 
17511   test -n "$ZIP" && break
17512 done
17513 
17514   else
17515     # The variable is set, but is it from the command line or the environment?
17516 
17517     # Try to remove the string !ZIP! from our list.
17518     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIP!/}
17519     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17520       # If it failed, the variable was not from the command line. Ignore it,
17521       # but warn the user (except for BASH, which is always set by the calling BASH).
17522       if test "xZIP" != xBASH; then
17523         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
17524 $as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
17525       fi
17526       # Try to locate tool using the code snippet
17527       for ac_prog in zip
17528 do
17529   # Extract the first word of "$ac_prog", so it can be a program name with args.
17530 set dummy $ac_prog; ac_word=$2
17531 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17532 $as_echo_n "checking for $ac_word... " >&6; }
17533 if ${ac_cv_path_ZIP+:} false; then :
17534   $as_echo_n "(cached) " >&6
17535 else
17536   case $ZIP in
17537   [\\/]* | ?:[\\/]*)
17538   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17539   ;;
17540   *)
17541   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17542 for as_dir in $PATH
17543 do
17544   IFS=$as_save_IFS
17545   test -z "$as_dir" && as_dir=.
17546     for ac_exec_ext in '' $ac_executable_extensions; do
17547   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17548     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17549     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17550     break 2
17551   fi
17552 done
17553   done
17554 IFS=$as_save_IFS
17555 
17556   ;;
17557 esac
17558 fi
17559 ZIP=$ac_cv_path_ZIP
17560 if test -n "$ZIP"; then
17561   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17562 $as_echo "$ZIP" >&6; }
17563 else
17564   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17565 $as_echo "no" >&6; }
17566 fi
17567 
17568 
17569   test -n "$ZIP" && break
17570 done
17571 
17572     else
17573       # If it succeeded, then it was overridden by the user. We will use it
17574       # for the tool.
17575 
17576       # First remove it from the list of overridden variables, so we can test
17577       # for unknown variables in the end.
17578       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17579 
17580       # Check if the provided tool contains a complete path.
17581       tool_specified="$ZIP"
17582       tool_basename="${tool_specified##*/}"
17583       if test "x$tool_basename" = "x$tool_specified"; then
17584         # A command without a complete path is provided, search $PATH.
17585         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
17586 $as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
17587         # Extract the first word of "$tool_basename", so it can be a program name with args.
17588 set dummy $tool_basename; ac_word=$2
17589 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17590 $as_echo_n "checking for $ac_word... " >&6; }
17591 if ${ac_cv_path_ZIP+:} false; then :
17592   $as_echo_n "(cached) " >&6
17593 else
17594   case $ZIP in
17595   [\\/]* | ?:[\\/]*)
17596   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17597   ;;
17598   *)
17599   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17600 for as_dir in $PATH
17601 do
17602   IFS=$as_save_IFS
17603   test -z "$as_dir" && as_dir=.
17604     for ac_exec_ext in '' $ac_executable_extensions; do
17605   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17606     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17607     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17608     break 2
17609   fi
17610 done
17611   done
17612 IFS=$as_save_IFS
17613 
17614   ;;
17615 esac
17616 fi
17617 ZIP=$ac_cv_path_ZIP
17618 if test -n "$ZIP"; then
17619   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17620 $as_echo "$ZIP" >&6; }
17621 else
17622   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17623 $as_echo "no" >&6; }
17624 fi
17625 
17626 
17627         if test "x$ZIP" = x; then
17628           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17629         fi
17630       else
17631         # Otherwise we believe it is a complete path. Use it as it is.
17632         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
17633 $as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
17634         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
17635 $as_echo_n "checking for ZIP... " >&6; }
17636         if test ! -x "$tool_specified"; then
17637           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17638 $as_echo "not found" >&6; }
17639           as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17640         fi
17641         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17642 $as_echo "$tool_specified" >&6; }
17643       fi
17644     fi
17645   fi
17646 
17647 
17648 
17649   if test "x$ZIP" = x; then
17650     as_fn_error $? "Could not find required tool for ZIP" "$LINENO" 5
17651   fi
17652 
17653 
17654 
17655   # Non-required basic tools
17656 
17657 
17658 
17659   # Publish this variable in the help.
17660 
17661 
17662   if test "x$LDD" = x; then
17663     # The variable is not set by user, try to locate tool using the code snippet
17664     for ac_prog in ldd
17665 do
17666   # Extract the first word of "$ac_prog", so it can be a program name with args.
17667 set dummy $ac_prog; ac_word=$2
17668 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17669 $as_echo_n "checking for $ac_word... " >&6; }
17670 if ${ac_cv_path_LDD+:} false; then :
17671   $as_echo_n "(cached) " >&6
17672 else
17673   case $LDD in
17674   [\\/]* | ?:[\\/]*)
17675   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17676   ;;
17677   *)
17678   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17679 for as_dir in $PATH
17680 do
17681   IFS=$as_save_IFS
17682   test -z "$as_dir" && as_dir=.
17683     for ac_exec_ext in '' $ac_executable_extensions; do
17684   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17685     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17686     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17687     break 2
17688   fi
17689 done
17690   done
17691 IFS=$as_save_IFS
17692 
17693   ;;
17694 esac
17695 fi
17696 LDD=$ac_cv_path_LDD
17697 if test -n "$LDD"; then
17698   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17699 $as_echo "$LDD" >&6; }
17700 else
17701   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17702 $as_echo "no" >&6; }
17703 fi
17704 
17705 
17706   test -n "$LDD" && break
17707 done
17708 
17709   else
17710     # The variable is set, but is it from the command line or the environment?
17711 
17712     # Try to remove the string !LDD! from our list.
17713     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
17714     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17715       # If it failed, the variable was not from the command line. Ignore it,
17716       # but warn the user (except for BASH, which is always set by the calling BASH).
17717       if test "xLDD" != xBASH; then
17718         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
17719 $as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
17720       fi
17721       # Try to locate tool using the code snippet
17722       for ac_prog in ldd
17723 do
17724   # Extract the first word of "$ac_prog", so it can be a program name with args.
17725 set dummy $ac_prog; ac_word=$2
17726 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17727 $as_echo_n "checking for $ac_word... " >&6; }
17728 if ${ac_cv_path_LDD+:} false; then :
17729   $as_echo_n "(cached) " >&6
17730 else
17731   case $LDD in
17732   [\\/]* | ?:[\\/]*)
17733   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17734   ;;
17735   *)
17736   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17737 for as_dir in $PATH
17738 do
17739   IFS=$as_save_IFS
17740   test -z "$as_dir" && as_dir=.
17741     for ac_exec_ext in '' $ac_executable_extensions; do
17742   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17743     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17744     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17745     break 2
17746   fi
17747 done
17748   done
17749 IFS=$as_save_IFS
17750 
17751   ;;
17752 esac
17753 fi
17754 LDD=$ac_cv_path_LDD
17755 if test -n "$LDD"; then
17756   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17757 $as_echo "$LDD" >&6; }
17758 else
17759   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17760 $as_echo "no" >&6; }
17761 fi
17762 
17763 
17764   test -n "$LDD" && break
17765 done
17766 
17767     else
17768       # If it succeeded, then it was overridden by the user. We will use it
17769       # for the tool.
17770 
17771       # First remove it from the list of overridden variables, so we can test
17772       # for unknown variables in the end.
17773       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17774 
17775       # Check if the provided tool contains a complete path.
17776       tool_specified="$LDD"
17777       tool_basename="${tool_specified##*/}"
17778       if test "x$tool_basename" = "x$tool_specified"; then
17779         # A command without a complete path is provided, search $PATH.
17780         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
17781 $as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
17782         # Extract the first word of "$tool_basename", so it can be a program name with args.
17783 set dummy $tool_basename; ac_word=$2
17784 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17785 $as_echo_n "checking for $ac_word... " >&6; }
17786 if ${ac_cv_path_LDD+:} false; then :
17787   $as_echo_n "(cached) " >&6
17788 else
17789   case $LDD in
17790   [\\/]* | ?:[\\/]*)
17791   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17792   ;;
17793   *)
17794   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17795 for as_dir in $PATH
17796 do
17797   IFS=$as_save_IFS
17798   test -z "$as_dir" && as_dir=.
17799     for ac_exec_ext in '' $ac_executable_extensions; do
17800   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17801     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17802     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17803     break 2
17804   fi
17805 done
17806   done
17807 IFS=$as_save_IFS
17808 
17809   ;;
17810 esac
17811 fi
17812 LDD=$ac_cv_path_LDD
17813 if test -n "$LDD"; then
17814   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17815 $as_echo "$LDD" >&6; }
17816 else
17817   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17818 $as_echo "no" >&6; }
17819 fi
17820 
17821 
17822         if test "x$LDD" = x; then
17823           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17824         fi
17825       else
17826         # Otherwise we believe it is a complete path. Use it as it is.
17827         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
17828 $as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
17829         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
17830 $as_echo_n "checking for LDD... " >&6; }
17831         if test ! -x "$tool_specified"; then
17832           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17833 $as_echo "not found" >&6; }
17834           as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
17835         fi
17836         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17837 $as_echo "$tool_specified" >&6; }
17838       fi
17839     fi
17840   fi
17841 
17842 
17843   if test "x$LDD" = "x"; then
17844     # List shared lib dependencies is used for
17845     # debug output and checking for forbidden dependencies.
17846     # We can build without it.
17847     LDD="true"
17848   fi
17849 
17850 
17851   # Publish this variable in the help.
17852 
17853 
17854   if test "x$READELF" = x; then
17855     # The variable is not set by user, try to locate tool using the code snippet
17856     for ac_prog in readelf greadelf
17857 do
17858   # Extract the first word of "$ac_prog", so it can be a program name with args.
17859 set dummy $ac_prog; ac_word=$2
17860 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17861 $as_echo_n "checking for $ac_word... " >&6; }
17862 if ${ac_cv_path_READELF+:} false; then :
17863   $as_echo_n "(cached) " >&6
17864 else
17865   case $READELF in
17866   [\\/]* | ?:[\\/]*)
17867   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
17868   ;;
17869   *)
17870   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17871 for as_dir in $PATH
17872 do
17873   IFS=$as_save_IFS
17874   test -z "$as_dir" && as_dir=.
17875     for ac_exec_ext in '' $ac_executable_extensions; do
17876   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17877     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
17878     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17879     break 2
17880   fi
17881 done
17882   done
17883 IFS=$as_save_IFS
17884 
17885   ;;
17886 esac
17887 fi
17888 READELF=$ac_cv_path_READELF
17889 if test -n "$READELF"; then
17890   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
17891 $as_echo "$READELF" >&6; }
17892 else
17893   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17894 $as_echo "no" >&6; }
17895 fi
17896 
17897 
17898   test -n "$READELF" && break
17899 done
17900 
17901   else
17902     # The variable is set, but is it from the command line or the environment?
17903 
17904     # Try to remove the string !READELF! from our list.
17905     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
17906     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17907       # If it failed, the variable was not from the command line. Ignore it,
17908       # but warn the user (except for BASH, which is always set by the calling BASH).
17909       if test "xREADELF" != xBASH; then
17910         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
17911 $as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
17912       fi
17913       # Try to locate tool using the code snippet
17914       for ac_prog in readelf greadelf
17915 do
17916   # Extract the first word of "$ac_prog", so it can be a program name with args.
17917 set dummy $ac_prog; ac_word=$2
17918 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17919 $as_echo_n "checking for $ac_word... " >&6; }
17920 if ${ac_cv_path_READELF+:} false; then :
17921   $as_echo_n "(cached) " >&6
17922 else
17923   case $READELF in
17924   [\\/]* | ?:[\\/]*)
17925   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
17926   ;;
17927   *)
17928   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17929 for as_dir in $PATH
17930 do
17931   IFS=$as_save_IFS
17932   test -z "$as_dir" && as_dir=.
17933     for ac_exec_ext in '' $ac_executable_extensions; do
17934   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17935     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
17936     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17937     break 2
17938   fi
17939 done
17940   done
17941 IFS=$as_save_IFS
17942 
17943   ;;
17944 esac
17945 fi
17946 READELF=$ac_cv_path_READELF
17947 if test -n "$READELF"; then
17948   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
17949 $as_echo "$READELF" >&6; }
17950 else
17951   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17952 $as_echo "no" >&6; }
17953 fi
17954 
17955 
17956   test -n "$READELF" && break
17957 done
17958 
17959     else
17960       # If it succeeded, then it was overridden by the user. We will use it
17961       # for the tool.
17962 
17963       # First remove it from the list of overridden variables, so we can test
17964       # for unknown variables in the end.
17965       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17966 
17967       # Check if the provided tool contains a complete path.
17968       tool_specified="$READELF"
17969       tool_basename="${tool_specified##*/}"
17970       if test "x$tool_basename" = "x$tool_specified"; then
17971         # A command without a complete path is provided, search $PATH.
17972         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
17973 $as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
17974         # Extract the first word of "$tool_basename", so it can be a program name with args.
17975 set dummy $tool_basename; ac_word=$2
17976 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17977 $as_echo_n "checking for $ac_word... " >&6; }
17978 if ${ac_cv_path_READELF+:} false; then :
17979   $as_echo_n "(cached) " >&6
17980 else
17981   case $READELF in
17982   [\\/]* | ?:[\\/]*)
17983   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
17984   ;;
17985   *)
17986   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17987 for as_dir in $PATH
17988 do
17989   IFS=$as_save_IFS
17990   test -z "$as_dir" && as_dir=.
17991     for ac_exec_ext in '' $ac_executable_extensions; do
17992   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17993     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
17994     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17995     break 2
17996   fi
17997 done
17998   done
17999 IFS=$as_save_IFS
18000 
18001   ;;
18002 esac
18003 fi
18004 READELF=$ac_cv_path_READELF
18005 if test -n "$READELF"; then
18006   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
18007 $as_echo "$READELF" >&6; }
18008 else
18009   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18010 $as_echo "no" >&6; }
18011 fi
18012 
18013 
18014         if test "x$READELF" = x; then
18015           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18016         fi
18017       else
18018         # Otherwise we believe it is a complete path. Use it as it is.
18019         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
18020 $as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
18021         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
18022 $as_echo_n "checking for READELF... " >&6; }
18023         if test ! -x "$tool_specified"; then
18024           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18025 $as_echo "not found" >&6; }
18026           as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
18027         fi
18028         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18029 $as_echo "$tool_specified" >&6; }
18030       fi
18031     fi
18032   fi
18033 
18034 
18035 
18036 
18037   # Publish this variable in the help.
18038 
18039 
18040   if test "x$HG" = x; then
18041     # The variable is not set by user, try to locate tool using the code snippet
18042     for ac_prog in hg
18043 do
18044   # Extract the first word of "$ac_prog", so it can be a program name with args.
18045 set dummy $ac_prog; ac_word=$2
18046 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18047 $as_echo_n "checking for $ac_word... " >&6; }
18048 if ${ac_cv_path_HG+:} false; then :
18049   $as_echo_n "(cached) " >&6
18050 else
18051   case $HG in
18052   [\\/]* | ?:[\\/]*)
18053   ac_cv_path_HG="$HG" # Let the user override the test with a path.
18054   ;;
18055   *)
18056   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18057 for as_dir in $PATH
18058 do
18059   IFS=$as_save_IFS
18060   test -z "$as_dir" && as_dir=.
18061     for ac_exec_ext in '' $ac_executable_extensions; do
18062   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18063     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18064     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18065     break 2
18066   fi
18067 done
18068   done
18069 IFS=$as_save_IFS
18070 
18071   ;;
18072 esac
18073 fi
18074 HG=$ac_cv_path_HG
18075 if test -n "$HG"; then
18076   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18077 $as_echo "$HG" >&6; }
18078 else
18079   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18080 $as_echo "no" >&6; }
18081 fi
18082 
18083 
18084   test -n "$HG" && break
18085 done
18086 
18087   else
18088     # The variable is set, but is it from the command line or the environment?
18089 
18090     # Try to remove the string !HG! from our list.
18091     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
18092     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18093       # If it failed, the variable was not from the command line. Ignore it,
18094       # but warn the user (except for BASH, which is always set by the calling BASH).
18095       if test "xHG" != xBASH; then
18096         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
18097 $as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
18098       fi
18099       # Try to locate tool using the code snippet
18100       for ac_prog in hg
18101 do
18102   # Extract the first word of "$ac_prog", so it can be a program name with args.
18103 set dummy $ac_prog; ac_word=$2
18104 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18105 $as_echo_n "checking for $ac_word... " >&6; }
18106 if ${ac_cv_path_HG+:} false; then :
18107   $as_echo_n "(cached) " >&6
18108 else
18109   case $HG in
18110   [\\/]* | ?:[\\/]*)
18111   ac_cv_path_HG="$HG" # Let the user override the test with a path.
18112   ;;
18113   *)
18114   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18115 for as_dir in $PATH
18116 do
18117   IFS=$as_save_IFS
18118   test -z "$as_dir" && as_dir=.
18119     for ac_exec_ext in '' $ac_executable_extensions; do
18120   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18121     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18122     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18123     break 2
18124   fi
18125 done
18126   done
18127 IFS=$as_save_IFS
18128 
18129   ;;
18130 esac
18131 fi
18132 HG=$ac_cv_path_HG
18133 if test -n "$HG"; then
18134   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18135 $as_echo "$HG" >&6; }
18136 else
18137   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18138 $as_echo "no" >&6; }
18139 fi
18140 
18141 
18142   test -n "$HG" && break
18143 done
18144 
18145     else
18146       # If it succeeded, then it was overridden by the user. We will use it
18147       # for the tool.
18148 
18149       # First remove it from the list of overridden variables, so we can test
18150       # for unknown variables in the end.
18151       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18152 
18153       # Check if the provided tool contains a complete path.
18154       tool_specified="$HG"
18155       tool_basename="${tool_specified##*/}"
18156       if test "x$tool_basename" = "x$tool_specified"; then
18157         # A command without a complete path is provided, search $PATH.
18158         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
18159 $as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
18160         # Extract the first word of "$tool_basename", so it can be a program name with args.
18161 set dummy $tool_basename; ac_word=$2
18162 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18163 $as_echo_n "checking for $ac_word... " >&6; }
18164 if ${ac_cv_path_HG+:} false; then :
18165   $as_echo_n "(cached) " >&6
18166 else
18167   case $HG in
18168   [\\/]* | ?:[\\/]*)
18169   ac_cv_path_HG="$HG" # Let the user override the test with a path.
18170   ;;
18171   *)
18172   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18173 for as_dir in $PATH
18174 do
18175   IFS=$as_save_IFS
18176   test -z "$as_dir" && as_dir=.
18177     for ac_exec_ext in '' $ac_executable_extensions; do
18178   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18179     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18180     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18181     break 2
18182   fi
18183 done
18184   done
18185 IFS=$as_save_IFS
18186 
18187   ;;
18188 esac
18189 fi
18190 HG=$ac_cv_path_HG
18191 if test -n "$HG"; then
18192   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18193 $as_echo "$HG" >&6; }
18194 else
18195   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18196 $as_echo "no" >&6; }
18197 fi
18198 
18199 
18200         if test "x$HG" = x; then
18201           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18202         fi
18203       else
18204         # Otherwise we believe it is a complete path. Use it as it is.
18205         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
18206 $as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
18207         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
18208 $as_echo_n "checking for HG... " >&6; }
18209         if test ! -x "$tool_specified"; then
18210           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18211 $as_echo "not found" >&6; }
18212           as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
18213         fi
18214         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18215 $as_echo "$tool_specified" >&6; }
18216       fi
18217     fi
18218   fi
18219 
18220 
18221 
18222 
18223   # Publish this variable in the help.
18224 
18225 
18226   if test "x$STAT" = x; then
18227     # The variable is not set by user, try to locate tool using the code snippet
18228     for ac_prog in stat
18229 do
18230   # Extract the first word of "$ac_prog", so it can be a program name with args.
18231 set dummy $ac_prog; ac_word=$2
18232 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18233 $as_echo_n "checking for $ac_word... " >&6; }
18234 if ${ac_cv_path_STAT+:} false; then :
18235   $as_echo_n "(cached) " >&6
18236 else
18237   case $STAT in
18238   [\\/]* | ?:[\\/]*)
18239   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18240   ;;
18241   *)
18242   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18243 for as_dir in $PATH
18244 do
18245   IFS=$as_save_IFS
18246   test -z "$as_dir" && as_dir=.
18247     for ac_exec_ext in '' $ac_executable_extensions; do
18248   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18249     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18250     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18251     break 2
18252   fi
18253 done
18254   done
18255 IFS=$as_save_IFS
18256 
18257   ;;
18258 esac
18259 fi
18260 STAT=$ac_cv_path_STAT
18261 if test -n "$STAT"; then
18262   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18263 $as_echo "$STAT" >&6; }
18264 else
18265   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18266 $as_echo "no" >&6; }
18267 fi
18268 
18269 
18270   test -n "$STAT" && break
18271 done
18272 
18273   else
18274     # The variable is set, but is it from the command line or the environment?
18275 
18276     # Try to remove the string !STAT! from our list.
18277     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
18278     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18279       # If it failed, the variable was not from the command line. Ignore it,
18280       # but warn the user (except for BASH, which is always set by the calling BASH).
18281       if test "xSTAT" != xBASH; then
18282         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
18283 $as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
18284       fi
18285       # Try to locate tool using the code snippet
18286       for ac_prog in stat
18287 do
18288   # Extract the first word of "$ac_prog", so it can be a program name with args.
18289 set dummy $ac_prog; ac_word=$2
18290 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18291 $as_echo_n "checking for $ac_word... " >&6; }
18292 if ${ac_cv_path_STAT+:} false; then :
18293   $as_echo_n "(cached) " >&6
18294 else
18295   case $STAT in
18296   [\\/]* | ?:[\\/]*)
18297   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18298   ;;
18299   *)
18300   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18301 for as_dir in $PATH
18302 do
18303   IFS=$as_save_IFS
18304   test -z "$as_dir" && as_dir=.
18305     for ac_exec_ext in '' $ac_executable_extensions; do
18306   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18307     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18308     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18309     break 2
18310   fi
18311 done
18312   done
18313 IFS=$as_save_IFS
18314 
18315   ;;
18316 esac
18317 fi
18318 STAT=$ac_cv_path_STAT
18319 if test -n "$STAT"; then
18320   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18321 $as_echo "$STAT" >&6; }
18322 else
18323   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18324 $as_echo "no" >&6; }
18325 fi
18326 
18327 
18328   test -n "$STAT" && break
18329 done
18330 
18331     else
18332       # If it succeeded, then it was overridden by the user. We will use it
18333       # for the tool.
18334 
18335       # First remove it from the list of overridden variables, so we can test
18336       # for unknown variables in the end.
18337       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18338 
18339       # Check if the provided tool contains a complete path.
18340       tool_specified="$STAT"
18341       tool_basename="${tool_specified##*/}"
18342       if test "x$tool_basename" = "x$tool_specified"; then
18343         # A command without a complete path is provided, search $PATH.
18344         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
18345 $as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
18346         # Extract the first word of "$tool_basename", so it can be a program name with args.
18347 set dummy $tool_basename; ac_word=$2
18348 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18349 $as_echo_n "checking for $ac_word... " >&6; }
18350 if ${ac_cv_path_STAT+:} false; then :
18351   $as_echo_n "(cached) " >&6
18352 else
18353   case $STAT in
18354   [\\/]* | ?:[\\/]*)
18355   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18356   ;;
18357   *)
18358   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18359 for as_dir in $PATH
18360 do
18361   IFS=$as_save_IFS
18362   test -z "$as_dir" && as_dir=.
18363     for ac_exec_ext in '' $ac_executable_extensions; do
18364   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18365     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18366     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18367     break 2
18368   fi
18369 done
18370   done
18371 IFS=$as_save_IFS
18372 
18373   ;;
18374 esac
18375 fi
18376 STAT=$ac_cv_path_STAT
18377 if test -n "$STAT"; then
18378   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18379 $as_echo "$STAT" >&6; }
18380 else
18381   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18382 $as_echo "no" >&6; }
18383 fi
18384 
18385 
18386         if test "x$STAT" = x; then
18387           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18388         fi
18389       else
18390         # Otherwise we believe it is a complete path. Use it as it is.
18391         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
18392 $as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
18393         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
18394 $as_echo_n "checking for STAT... " >&6; }
18395         if test ! -x "$tool_specified"; then
18396           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18397 $as_echo "not found" >&6; }
18398           as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
18399         fi
18400         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18401 $as_echo "$tool_specified" >&6; }
18402       fi
18403     fi
18404   fi
18405 
18406 
18407 
18408 
18409   # Publish this variable in the help.
18410 
18411 
18412   if test "x$TIME" = x; then
18413     # The variable is not set by user, try to locate tool using the code snippet
18414     for ac_prog in time
18415 do
18416   # Extract the first word of "$ac_prog", so it can be a program name with args.
18417 set dummy $ac_prog; ac_word=$2
18418 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18419 $as_echo_n "checking for $ac_word... " >&6; }
18420 if ${ac_cv_path_TIME+:} false; then :
18421   $as_echo_n "(cached) " >&6
18422 else
18423   case $TIME in
18424   [\\/]* | ?:[\\/]*)
18425   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18426   ;;
18427   *)
18428   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18429 for as_dir in $PATH
18430 do
18431   IFS=$as_save_IFS
18432   test -z "$as_dir" && as_dir=.
18433     for ac_exec_ext in '' $ac_executable_extensions; do
18434   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18435     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18436     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18437     break 2
18438   fi
18439 done
18440   done
18441 IFS=$as_save_IFS
18442 
18443   ;;
18444 esac
18445 fi
18446 TIME=$ac_cv_path_TIME
18447 if test -n "$TIME"; then
18448   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18449 $as_echo "$TIME" >&6; }
18450 else
18451   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18452 $as_echo "no" >&6; }
18453 fi
18454 
18455 
18456   test -n "$TIME" && break
18457 done
18458 
18459   else
18460     # The variable is set, but is it from the command line or the environment?
18461 
18462     # Try to remove the string !TIME! from our list.
18463     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
18464     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18465       # If it failed, the variable was not from the command line. Ignore it,
18466       # but warn the user (except for BASH, which is always set by the calling BASH).
18467       if test "xTIME" != xBASH; then
18468         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
18469 $as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
18470       fi
18471       # Try to locate tool using the code snippet
18472       for ac_prog in time
18473 do
18474   # Extract the first word of "$ac_prog", so it can be a program name with args.
18475 set dummy $ac_prog; ac_word=$2
18476 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18477 $as_echo_n "checking for $ac_word... " >&6; }
18478 if ${ac_cv_path_TIME+:} false; then :
18479   $as_echo_n "(cached) " >&6
18480 else
18481   case $TIME in
18482   [\\/]* | ?:[\\/]*)
18483   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18484   ;;
18485   *)
18486   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18487 for as_dir in $PATH
18488 do
18489   IFS=$as_save_IFS
18490   test -z "$as_dir" && as_dir=.
18491     for ac_exec_ext in '' $ac_executable_extensions; do
18492   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18493     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18494     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18495     break 2
18496   fi
18497 done
18498   done
18499 IFS=$as_save_IFS
18500 
18501   ;;
18502 esac
18503 fi
18504 TIME=$ac_cv_path_TIME
18505 if test -n "$TIME"; then
18506   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18507 $as_echo "$TIME" >&6; }
18508 else
18509   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18510 $as_echo "no" >&6; }
18511 fi
18512 
18513 
18514   test -n "$TIME" && break
18515 done
18516 
18517     else
18518       # If it succeeded, then it was overridden by the user. We will use it
18519       # for the tool.
18520 
18521       # First remove it from the list of overridden variables, so we can test
18522       # for unknown variables in the end.
18523       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18524 
18525       # Check if the provided tool contains a complete path.
18526       tool_specified="$TIME"
18527       tool_basename="${tool_specified##*/}"
18528       if test "x$tool_basename" = "x$tool_specified"; then
18529         # A command without a complete path is provided, search $PATH.
18530         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
18531 $as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
18532         # Extract the first word of "$tool_basename", so it can be a program name with args.
18533 set dummy $tool_basename; ac_word=$2
18534 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18535 $as_echo_n "checking for $ac_word... " >&6; }
18536 if ${ac_cv_path_TIME+:} false; then :
18537   $as_echo_n "(cached) " >&6
18538 else
18539   case $TIME in
18540   [\\/]* | ?:[\\/]*)
18541   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18542   ;;
18543   *)
18544   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18545 for as_dir in $PATH
18546 do
18547   IFS=$as_save_IFS
18548   test -z "$as_dir" && as_dir=.
18549     for ac_exec_ext in '' $ac_executable_extensions; do
18550   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18551     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18552     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18553     break 2
18554   fi
18555 done
18556   done
18557 IFS=$as_save_IFS
18558 
18559   ;;
18560 esac
18561 fi
18562 TIME=$ac_cv_path_TIME
18563 if test -n "$TIME"; then
18564   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18565 $as_echo "$TIME" >&6; }
18566 else
18567   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18568 $as_echo "no" >&6; }
18569 fi
18570 
18571 
18572         if test "x$TIME" = x; then
18573           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18574         fi
18575       else
18576         # Otherwise we believe it is a complete path. Use it as it is.
18577         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
18578 $as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
18579         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
18580 $as_echo_n "checking for TIME... " >&6; }
18581         if test ! -x "$tool_specified"; then
18582           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18583 $as_echo "not found" >&6; }
18584           as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
18585         fi
18586         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18587 $as_echo "$tool_specified" >&6; }
18588       fi
18589     fi
18590   fi
18591 
18592 
18593   # Check if it's GNU time
18594   IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
18595   if test "x$IS_GNU_TIME" != x; then
18596     IS_GNU_TIME=yes
18597   else
18598     IS_GNU_TIME=no
18599   fi
18600 
18601 
18602   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
18603 
18604 
18605 
18606   # Publish this variable in the help.
18607 
18608 
18609   if test "x$COMM" = x; then
18610     # The variable is not set by user, try to locate tool using the code snippet
18611     for ac_prog in comm
18612 do
18613   # Extract the first word of "$ac_prog", so it can be a program name with args.
18614 set dummy $ac_prog; ac_word=$2
18615 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18616 $as_echo_n "checking for $ac_word... " >&6; }
18617 if ${ac_cv_path_COMM+:} false; then :
18618   $as_echo_n "(cached) " >&6
18619 else
18620   case $COMM in
18621   [\\/]* | ?:[\\/]*)
18622   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
18623   ;;
18624   *)
18625   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18626 for as_dir in $PATH
18627 do
18628   IFS=$as_save_IFS
18629   test -z "$as_dir" && as_dir=.
18630     for ac_exec_ext in '' $ac_executable_extensions; do
18631   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18632     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
18633     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18634     break 2
18635   fi
18636 done
18637   done
18638 IFS=$as_save_IFS
18639 
18640   ;;
18641 esac
18642 fi
18643 COMM=$ac_cv_path_COMM
18644 if test -n "$COMM"; then
18645   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
18646 $as_echo "$COMM" >&6; }
18647 else
18648   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18649 $as_echo "no" >&6; }
18650 fi
18651 
18652 
18653   test -n "$COMM" && break
18654 done
18655 
18656   else
18657     # The variable is set, but is it from the command line or the environment?
18658 
18659     # Try to remove the string !COMM! from our list.
18660     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
18661     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18662       # If it failed, the variable was not from the command line. Ignore it,
18663       # but warn the user (except for BASH, which is always set by the calling BASH).
18664       if test "xCOMM" != xBASH; then
18665         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
18666 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
18667       fi
18668       # Try to locate tool using the code snippet
18669       for ac_prog in comm
18670 do
18671   # Extract the first word of "$ac_prog", so it can be a program name with args.
18672 set dummy $ac_prog; ac_word=$2
18673 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18674 $as_echo_n "checking for $ac_word... " >&6; }
18675 if ${ac_cv_path_COMM+:} false; then :
18676   $as_echo_n "(cached) " >&6
18677 else
18678   case $COMM in
18679   [\\/]* | ?:[\\/]*)
18680   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
18681   ;;
18682   *)
18683   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18684 for as_dir in $PATH
18685 do
18686   IFS=$as_save_IFS
18687   test -z "$as_dir" && as_dir=.
18688     for ac_exec_ext in '' $ac_executable_extensions; do
18689   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18690     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
18691     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18692     break 2
18693   fi
18694 done
18695   done
18696 IFS=$as_save_IFS
18697 
18698   ;;
18699 esac
18700 fi
18701 COMM=$ac_cv_path_COMM
18702 if test -n "$COMM"; then
18703   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
18704 $as_echo "$COMM" >&6; }
18705 else
18706   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18707 $as_echo "no" >&6; }
18708 fi
18709 
18710 
18711   test -n "$COMM" && break
18712 done
18713 
18714     else
18715       # If it succeeded, then it was overridden by the user. We will use it
18716       # for the tool.
18717 
18718       # First remove it from the list of overridden variables, so we can test
18719       # for unknown variables in the end.
18720       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18721 
18722       # Check if the provided tool contains a complete path.
18723       tool_specified="$COMM"
18724       tool_basename="${tool_specified##*/}"
18725       if test "x$tool_basename" = "x$tool_specified"; then
18726         # A command without a complete path is provided, search $PATH.
18727         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
18728 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
18729         # Extract the first word of "$tool_basename", so it can be a program name with args.
18730 set dummy $tool_basename; ac_word=$2
18731 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18732 $as_echo_n "checking for $ac_word... " >&6; }
18733 if ${ac_cv_path_COMM+:} false; then :
18734   $as_echo_n "(cached) " >&6
18735 else
18736   case $COMM in
18737   [\\/]* | ?:[\\/]*)
18738   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
18739   ;;
18740   *)
18741   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18742 for as_dir in $PATH
18743 do
18744   IFS=$as_save_IFS
18745   test -z "$as_dir" && as_dir=.
18746     for ac_exec_ext in '' $ac_executable_extensions; do
18747   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18748     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
18749     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18750     break 2
18751   fi
18752 done
18753   done
18754 IFS=$as_save_IFS
18755 
18756   ;;
18757 esac
18758 fi
18759 COMM=$ac_cv_path_COMM
18760 if test -n "$COMM"; then
18761   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
18762 $as_echo "$COMM" >&6; }
18763 else
18764   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18765 $as_echo "no" >&6; }
18766 fi
18767 
18768 
18769         if test "x$COMM" = x; then
18770           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18771         fi
18772       else
18773         # Otherwise we believe it is a complete path. Use it as it is.
18774         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
18775 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
18776         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
18777 $as_echo_n "checking for COMM... " >&6; }
18778         if test ! -x "$tool_specified"; then
18779           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18780 $as_echo "not found" >&6; }
18781           as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
18782         fi
18783         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18784 $as_echo "$tool_specified" >&6; }
18785       fi
18786     fi
18787   fi
18788 
18789 
18790 
18791   if test "x$COMM" = x; then
18792     as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
18793   fi
18794 
18795 
18796   fi
18797 
18798   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
18799 
18800 
18801 
18802   # Publish this variable in the help.
18803 
18804 
18805   if test "x$DSYMUTIL" = x; then
18806     # The variable is not set by user, try to locate tool using the code snippet
18807     for ac_prog in dsymutil
18808 do
18809   # Extract the first word of "$ac_prog", so it can be a program name with args.
18810 set dummy $ac_prog; ac_word=$2
18811 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18812 $as_echo_n "checking for $ac_word... " >&6; }
18813 if ${ac_cv_path_DSYMUTIL+:} false; then :
18814   $as_echo_n "(cached) " >&6
18815 else
18816   case $DSYMUTIL in
18817   [\\/]* | ?:[\\/]*)
18818   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18819   ;;
18820   *)
18821   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18822 for as_dir in $PATH
18823 do
18824   IFS=$as_save_IFS
18825   test -z "$as_dir" && as_dir=.
18826     for ac_exec_ext in '' $ac_executable_extensions; do
18827   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18828     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18829     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18830     break 2
18831   fi
18832 done
18833   done
18834 IFS=$as_save_IFS
18835 
18836   ;;
18837 esac
18838 fi
18839 DSYMUTIL=$ac_cv_path_DSYMUTIL
18840 if test -n "$DSYMUTIL"; then
18841   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18842 $as_echo "$DSYMUTIL" >&6; }
18843 else
18844   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18845 $as_echo "no" >&6; }
18846 fi
18847 
18848 
18849   test -n "$DSYMUTIL" && break
18850 done
18851 
18852   else
18853     # The variable is set, but is it from the command line or the environment?
18854 
18855     # Try to remove the string !DSYMUTIL! from our list.
18856     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
18857     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18858       # If it failed, the variable was not from the command line. Ignore it,
18859       # but warn the user (except for BASH, which is always set by the calling BASH).
18860       if test "xDSYMUTIL" != xBASH; then
18861         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
18862 $as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
18863       fi
18864       # Try to locate tool using the code snippet
18865       for ac_prog in dsymutil
18866 do
18867   # Extract the first word of "$ac_prog", so it can be a program name with args.
18868 set dummy $ac_prog; ac_word=$2
18869 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18870 $as_echo_n "checking for $ac_word... " >&6; }
18871 if ${ac_cv_path_DSYMUTIL+:} false; then :
18872   $as_echo_n "(cached) " >&6
18873 else
18874   case $DSYMUTIL in
18875   [\\/]* | ?:[\\/]*)
18876   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18877   ;;
18878   *)
18879   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18880 for as_dir in $PATH
18881 do
18882   IFS=$as_save_IFS
18883   test -z "$as_dir" && as_dir=.
18884     for ac_exec_ext in '' $ac_executable_extensions; do
18885   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18886     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18887     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18888     break 2
18889   fi
18890 done
18891   done
18892 IFS=$as_save_IFS
18893 
18894   ;;
18895 esac
18896 fi
18897 DSYMUTIL=$ac_cv_path_DSYMUTIL
18898 if test -n "$DSYMUTIL"; then
18899   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18900 $as_echo "$DSYMUTIL" >&6; }
18901 else
18902   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18903 $as_echo "no" >&6; }
18904 fi
18905 
18906 
18907   test -n "$DSYMUTIL" && break
18908 done
18909 
18910     else
18911       # If it succeeded, then it was overridden by the user. We will use it
18912       # for the tool.
18913 
18914       # First remove it from the list of overridden variables, so we can test
18915       # for unknown variables in the end.
18916       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18917 
18918       # Check if the provided tool contains a complete path.
18919       tool_specified="$DSYMUTIL"
18920       tool_basename="${tool_specified##*/}"
18921       if test "x$tool_basename" = "x$tool_specified"; then
18922         # A command without a complete path is provided, search $PATH.
18923         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
18924 $as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
18925         # Extract the first word of "$tool_basename", so it can be a program name with args.
18926 set dummy $tool_basename; ac_word=$2
18927 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18928 $as_echo_n "checking for $ac_word... " >&6; }
18929 if ${ac_cv_path_DSYMUTIL+:} false; then :
18930   $as_echo_n "(cached) " >&6
18931 else
18932   case $DSYMUTIL in
18933   [\\/]* | ?:[\\/]*)
18934   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18935   ;;
18936   *)
18937   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18938 for as_dir in $PATH
18939 do
18940   IFS=$as_save_IFS
18941   test -z "$as_dir" && as_dir=.
18942     for ac_exec_ext in '' $ac_executable_extensions; do
18943   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18944     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18945     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18946     break 2
18947   fi
18948 done
18949   done
18950 IFS=$as_save_IFS
18951 
18952   ;;
18953 esac
18954 fi
18955 DSYMUTIL=$ac_cv_path_DSYMUTIL
18956 if test -n "$DSYMUTIL"; then
18957   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18958 $as_echo "$DSYMUTIL" >&6; }
18959 else
18960   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18961 $as_echo "no" >&6; }
18962 fi
18963 
18964 
18965         if test "x$DSYMUTIL" = x; then
18966           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18967         fi
18968       else
18969         # Otherwise we believe it is a complete path. Use it as it is.
18970         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
18971 $as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
18972         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
18973 $as_echo_n "checking for DSYMUTIL... " >&6; }
18974         if test ! -x "$tool_specified"; then
18975           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18976 $as_echo "not found" >&6; }
18977           as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
18978         fi
18979         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18980 $as_echo "$tool_specified" >&6; }
18981       fi
18982     fi
18983   fi
18984 
18985 
18986 
18987   if test "x$DSYMUTIL" = x; then
18988     as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
18989   fi
18990 
18991 
18992 
18993 
18994 
18995   # Publish this variable in the help.
18996 
18997 
18998   if test "x$XATTR" = x; then
18999     # The variable is not set by user, try to locate tool using the code snippet
19000     for ac_prog in xattr
19001 do
19002   # Extract the first word of "$ac_prog", so it can be a program name with args.
19003 set dummy $ac_prog; ac_word=$2
19004 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19005 $as_echo_n "checking for $ac_word... " >&6; }
19006 if ${ac_cv_path_XATTR+:} false; then :
19007   $as_echo_n "(cached) " >&6
19008 else
19009   case $XATTR in
19010   [\\/]* | ?:[\\/]*)
19011   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19012   ;;
19013   *)
19014   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19015 for as_dir in $PATH
19016 do
19017   IFS=$as_save_IFS
19018   test -z "$as_dir" && as_dir=.
19019     for ac_exec_ext in '' $ac_executable_extensions; do
19020   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19021     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19022     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19023     break 2
19024   fi
19025 done
19026   done
19027 IFS=$as_save_IFS
19028 
19029   ;;
19030 esac
19031 fi
19032 XATTR=$ac_cv_path_XATTR
19033 if test -n "$XATTR"; then
19034   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19035 $as_echo "$XATTR" >&6; }
19036 else
19037   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19038 $as_echo "no" >&6; }
19039 fi
19040 
19041 
19042   test -n "$XATTR" && break
19043 done
19044 
19045   else
19046     # The variable is set, but is it from the command line or the environment?
19047 
19048     # Try to remove the string !XATTR! from our list.
19049     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
19050     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19051       # If it failed, the variable was not from the command line. Ignore it,
19052       # but warn the user (except for BASH, which is always set by the calling BASH).
19053       if test "xXATTR" != xBASH; then
19054         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
19055 $as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
19056       fi
19057       # Try to locate tool using the code snippet
19058       for ac_prog in xattr
19059 do
19060   # Extract the first word of "$ac_prog", so it can be a program name with args.
19061 set dummy $ac_prog; ac_word=$2
19062 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19063 $as_echo_n "checking for $ac_word... " >&6; }
19064 if ${ac_cv_path_XATTR+:} false; then :
19065   $as_echo_n "(cached) " >&6
19066 else
19067   case $XATTR in
19068   [\\/]* | ?:[\\/]*)
19069   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19070   ;;
19071   *)
19072   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19073 for as_dir in $PATH
19074 do
19075   IFS=$as_save_IFS
19076   test -z "$as_dir" && as_dir=.
19077     for ac_exec_ext in '' $ac_executable_extensions; do
19078   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19079     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19080     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19081     break 2
19082   fi
19083 done
19084   done
19085 IFS=$as_save_IFS
19086 
19087   ;;
19088 esac
19089 fi
19090 XATTR=$ac_cv_path_XATTR
19091 if test -n "$XATTR"; then
19092   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19093 $as_echo "$XATTR" >&6; }
19094 else
19095   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19096 $as_echo "no" >&6; }
19097 fi
19098 
19099 
19100   test -n "$XATTR" && break
19101 done
19102 
19103     else
19104       # If it succeeded, then it was overridden by the user. We will use it
19105       # for the tool.
19106 
19107       # First remove it from the list of overridden variables, so we can test
19108       # for unknown variables in the end.
19109       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19110 
19111       # Check if the provided tool contains a complete path.
19112       tool_specified="$XATTR"
19113       tool_basename="${tool_specified##*/}"
19114       if test "x$tool_basename" = "x$tool_specified"; then
19115         # A command without a complete path is provided, search $PATH.
19116         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
19117 $as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
19118         # Extract the first word of "$tool_basename", so it can be a program name with args.
19119 set dummy $tool_basename; ac_word=$2
19120 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19121 $as_echo_n "checking for $ac_word... " >&6; }
19122 if ${ac_cv_path_XATTR+:} false; then :
19123   $as_echo_n "(cached) " >&6
19124 else
19125   case $XATTR in
19126   [\\/]* | ?:[\\/]*)
19127   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19128   ;;
19129   *)
19130   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19131 for as_dir in $PATH
19132 do
19133   IFS=$as_save_IFS
19134   test -z "$as_dir" && as_dir=.
19135     for ac_exec_ext in '' $ac_executable_extensions; do
19136   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19137     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19138     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19139     break 2
19140   fi
19141 done
19142   done
19143 IFS=$as_save_IFS
19144 
19145   ;;
19146 esac
19147 fi
19148 XATTR=$ac_cv_path_XATTR
19149 if test -n "$XATTR"; then
19150   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19151 $as_echo "$XATTR" >&6; }
19152 else
19153   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19154 $as_echo "no" >&6; }
19155 fi
19156 
19157 
19158         if test "x$XATTR" = x; then
19159           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19160         fi
19161       else
19162         # Otherwise we believe it is a complete path. Use it as it is.
19163         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
19164 $as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
19165         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
19166 $as_echo_n "checking for XATTR... " >&6; }
19167         if test ! -x "$tool_specified"; then
19168           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19169 $as_echo "not found" >&6; }
19170           as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
19171         fi
19172         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19173 $as_echo "$tool_specified" >&6; }
19174       fi
19175     fi
19176   fi
19177 
19178 
19179 
19180   if test "x$XATTR" = x; then
19181     as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
19182   fi
19183 
19184 
19185 
19186 
19187   # Publish this variable in the help.
19188 
19189 
19190   if test "x$CODESIGN" = x; then
19191     # The variable is not set by user, try to locate tool using the code snippet
19192     for ac_prog in codesign
19193 do
19194   # Extract the first word of "$ac_prog", so it can be a program name with args.
19195 set dummy $ac_prog; ac_word=$2
19196 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19197 $as_echo_n "checking for $ac_word... " >&6; }
19198 if ${ac_cv_path_CODESIGN+:} false; then :
19199   $as_echo_n "(cached) " >&6
19200 else
19201   case $CODESIGN in
19202   [\\/]* | ?:[\\/]*)
19203   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19204   ;;
19205   *)
19206   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19207 for as_dir in $PATH
19208 do
19209   IFS=$as_save_IFS
19210   test -z "$as_dir" && as_dir=.
19211     for ac_exec_ext in '' $ac_executable_extensions; do
19212   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19213     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19214     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19215     break 2
19216   fi
19217 done
19218   done
19219 IFS=$as_save_IFS
19220 
19221   ;;
19222 esac
19223 fi
19224 CODESIGN=$ac_cv_path_CODESIGN
19225 if test -n "$CODESIGN"; then
19226   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19227 $as_echo "$CODESIGN" >&6; }
19228 else
19229   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19230 $as_echo "no" >&6; }
19231 fi
19232 
19233 
19234   test -n "$CODESIGN" && break
19235 done
19236 
19237   else
19238     # The variable is set, but is it from the command line or the environment?
19239 
19240     # Try to remove the string !CODESIGN! from our list.
19241     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
19242     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19243       # If it failed, the variable was not from the command line. Ignore it,
19244       # but warn the user (except for BASH, which is always set by the calling BASH).
19245       if test "xCODESIGN" != xBASH; then
19246         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
19247 $as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
19248       fi
19249       # Try to locate tool using the code snippet
19250       for ac_prog in codesign
19251 do
19252   # Extract the first word of "$ac_prog", so it can be a program name with args.
19253 set dummy $ac_prog; ac_word=$2
19254 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19255 $as_echo_n "checking for $ac_word... " >&6; }
19256 if ${ac_cv_path_CODESIGN+:} false; then :
19257   $as_echo_n "(cached) " >&6
19258 else
19259   case $CODESIGN in
19260   [\\/]* | ?:[\\/]*)
19261   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19262   ;;
19263   *)
19264   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19265 for as_dir in $PATH
19266 do
19267   IFS=$as_save_IFS
19268   test -z "$as_dir" && as_dir=.
19269     for ac_exec_ext in '' $ac_executable_extensions; do
19270   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19271     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19272     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19273     break 2
19274   fi
19275 done
19276   done
19277 IFS=$as_save_IFS
19278 
19279   ;;
19280 esac
19281 fi
19282 CODESIGN=$ac_cv_path_CODESIGN
19283 if test -n "$CODESIGN"; then
19284   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19285 $as_echo "$CODESIGN" >&6; }
19286 else
19287   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19288 $as_echo "no" >&6; }
19289 fi
19290 
19291 
19292   test -n "$CODESIGN" && break
19293 done
19294 
19295     else
19296       # If it succeeded, then it was overridden by the user. We will use it
19297       # for the tool.
19298 
19299       # First remove it from the list of overridden variables, so we can test
19300       # for unknown variables in the end.
19301       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19302 
19303       # Check if the provided tool contains a complete path.
19304       tool_specified="$CODESIGN"
19305       tool_basename="${tool_specified##*/}"
19306       if test "x$tool_basename" = "x$tool_specified"; then
19307         # A command without a complete path is provided, search $PATH.
19308         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
19309 $as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
19310         # Extract the first word of "$tool_basename", so it can be a program name with args.
19311 set dummy $tool_basename; ac_word=$2
19312 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19313 $as_echo_n "checking for $ac_word... " >&6; }
19314 if ${ac_cv_path_CODESIGN+:} false; then :
19315   $as_echo_n "(cached) " >&6
19316 else
19317   case $CODESIGN in
19318   [\\/]* | ?:[\\/]*)
19319   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19320   ;;
19321   *)
19322   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19323 for as_dir in $PATH
19324 do
19325   IFS=$as_save_IFS
19326   test -z "$as_dir" && as_dir=.
19327     for ac_exec_ext in '' $ac_executable_extensions; do
19328   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19329     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19330     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19331     break 2
19332   fi
19333 done
19334   done
19335 IFS=$as_save_IFS
19336 
19337   ;;
19338 esac
19339 fi
19340 CODESIGN=$ac_cv_path_CODESIGN
19341 if test -n "$CODESIGN"; then
19342   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19343 $as_echo "$CODESIGN" >&6; }
19344 else
19345   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19346 $as_echo "no" >&6; }
19347 fi
19348 
19349 
19350         if test "x$CODESIGN" = x; then
19351           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19352         fi
19353       else
19354         # Otherwise we believe it is a complete path. Use it as it is.
19355         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
19356 $as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
19357         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
19358 $as_echo_n "checking for CODESIGN... " >&6; }
19359         if test ! -x "$tool_specified"; then
19360           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19361 $as_echo "not found" >&6; }
19362           as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
19363         fi
19364         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19365 $as_echo "$tool_specified" >&6; }
19366       fi
19367     fi
19368   fi
19369 
19370 
19371     if test "x$CODESIGN" != "x"; then
19372       # Verify that the openjdk_codesign certificate is present
19373       { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
19374 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
19375       rm -f codesign-testfile
19376       touch codesign-testfile
19377       codesign -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
19378       rm -f codesign-testfile
19379       if test "x$CODESIGN" = x; then
19380         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19381 $as_echo "no" >&6; }
19382       else
19383         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19384 $as_echo "yes" >&6; }
19385       fi
19386     fi
19387   fi
19388 
19389 
19390 # Check if pkg-config is available.
19391 
19392 
19393 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
19394         if test -n "$ac_tool_prefix"; then
19395   # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
19396 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
19397 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19398 $as_echo_n "checking for $ac_word... " >&6; }
19399 if ${ac_cv_path_PKG_CONFIG+:} false; then :
19400   $as_echo_n "(cached) " >&6
19401 else
19402   case $PKG_CONFIG in
19403   [\\/]* | ?:[\\/]*)
19404   ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
19405   ;;
19406   *)
19407   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19408 for as_dir in $PATH
19409 do
19410   IFS=$as_save_IFS
19411   test -z "$as_dir" && as_dir=.
19412     for ac_exec_ext in '' $ac_executable_extensions; do
19413   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19414     ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
19415     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19416     break 2
19417   fi
19418 done
19419   done
19420 IFS=$as_save_IFS
19421 
19422   ;;
19423 esac
19424 fi
19425 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
19426 if test -n "$PKG_CONFIG"; then
19427   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
19428 $as_echo "$PKG_CONFIG" >&6; }
19429 else
19430   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19431 $as_echo "no" >&6; }
19432 fi
19433 
19434 
19435 fi
19436 if test -z "$ac_cv_path_PKG_CONFIG"; then
19437   ac_pt_PKG_CONFIG=$PKG_CONFIG
19438   # Extract the first word of "pkg-config", so it can be a program name with args.
19439 set dummy pkg-config; 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_path_ac_pt_PKG_CONFIG+:} false; then :
19443   $as_echo_n "(cached) " >&6
19444 else
19445   case $ac_pt_PKG_CONFIG in
19446   [\\/]* | ?:[\\/]*)
19447   ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
19448   ;;
19449   *)
19450   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19451 for as_dir in $PATH
19452 do
19453   IFS=$as_save_IFS
19454   test -z "$as_dir" && as_dir=.
19455     for ac_exec_ext in '' $ac_executable_extensions; do
19456   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19457     ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
19458     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19459     break 2
19460   fi
19461 done
19462   done
19463 IFS=$as_save_IFS
19464 
19465   ;;
19466 esac
19467 fi
19468 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
19469 if test -n "$ac_pt_PKG_CONFIG"; then
19470   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
19471 $as_echo "$ac_pt_PKG_CONFIG" >&6; }
19472 else
19473   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19474 $as_echo "no" >&6; }
19475 fi
19476 
19477   if test "x$ac_pt_PKG_CONFIG" = x; then
19478     PKG_CONFIG=""
19479   else
19480     case $cross_compiling:$ac_tool_warned in
19481 yes:)
19482 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
19483 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
19484 ac_tool_warned=yes ;;
19485 esac
19486     PKG_CONFIG=$ac_pt_PKG_CONFIG
19487   fi
19488 else
19489   PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
19490 fi
19491 
19492 fi
19493 if test -n "$PKG_CONFIG"; then
19494         _pkg_min_version=0.9.0
19495         { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
19496 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
19497         if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
19498                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19499 $as_echo "yes" >&6; }
19500         else
19501                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19502 $as_echo "no" >&6; }
19503                 PKG_CONFIG=""
19504         fi
19505 
19506 fi
19507 
19508 # After basic tools have been setup, we can check build os specific details.
19509 
19510   ###############################################################################
19511 
19512   # Note that this is the build platform OS version!
19513 
19514   OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`"
19515   OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`"
19516   OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`"
19517   OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`"
19518 
19519 
19520 
19521 
19522 
19523 # Setup builddeps, for automatic downloading of tools we need.
19524 # This is needed before we can call BDEPS_CHECK_MODULE, which is done in
19525 # boot-jdk setup, but we need to have basic tools setup first.
19526 
19527 
19528 # Check whether --with-builddeps-conf was given.
19529 if test "${with_builddeps_conf+set}" = set; then :
19530   withval=$with_builddeps_conf;
19531 fi
19532 
19533 
19534 
19535 # Check whether --with-builddeps-server was given.
19536 if test "${with_builddeps_server+set}" = set; then :
19537   withval=$with_builddeps_server;
19538 fi
19539 
19540 
19541 
19542 # Check whether --with-builddeps-dir was given.
19543 if test "${with_builddeps_dir+set}" = set; then :
19544   withval=$with_builddeps_dir;
19545 else
19546   with_builddeps_dir=/localhome/builddeps
19547 fi
19548 
19549 
19550 
19551 # Check whether --with-builddeps-group was given.
19552 if test "${with_builddeps_group+set}" = set; then :
19553   withval=$with_builddeps_group;
19554 fi
19555 
19556 
19557 
19558 
19559   if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
19560     if test "x$with_builddeps_conf" != x; then
19561       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for supplied builddeps configuration file" >&5
19562 $as_echo_n "checking for supplied builddeps configuration file... " >&6; }
19563       builddepsfile=$with_builddeps_conf
19564       if test -s $builddepsfile; then
19565         . $builddepsfile
19566         { $as_echo "$as_me:${as_lineno-$LINENO}: result: loaded!" >&5
19567 $as_echo "loaded!" >&6; }
19568       else
19569         as_fn_error $? "The given builddeps conf file $with_builddeps_conf could not be loaded!" "$LINENO" 5
19570       fi
19571     else
19572       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for builddeps.conf files in sources..." >&5
19573 $as_echo_n "checking for builddeps.conf files in sources...... " >&6; }
19574       builddepsfile=`mktemp`
19575       touch $builddepsfile
19576       # Put all found confs into a single file.
19577       find ${SRC_ROOT} -name builddeps.conf -exec cat \{\} \; >> $builddepsfile
19578       # Source the file to acquire the variables
19579       if test -s $builddepsfile; then
19580         . $builddepsfile
19581         { $as_echo "$as_me:${as_lineno-$LINENO}: result: found at least one!" >&5
19582 $as_echo "found at least one!" >&6; }
19583       else
19584         as_fn_error $? "Could not find any builddeps.conf at all!" "$LINENO" 5
19585       fi
19586     fi
19587     # Create build and target names that use _ instead of "-" and ".".
19588     # This is necessary to use them in variable names.
19589     build_var=`echo ${OPENJDK_BUILD_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19590     target_var=`echo ${OPENJDK_TARGET_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19591     # Extract rewrite information for build and target
19592     eval rewritten_build=\${REWRITE_${build_var}}
19593     if test "x$rewritten_build" = x; then
19594       rewritten_build=${OPENJDK_BUILD_AUTOCONF_NAME}
19595       echo Build stays the same $rewritten_build
19596     else
19597       echo Rewriting build for builddeps into $rewritten_build
19598     fi
19599     eval rewritten_target=\${REWRITE_${target_var}}
19600     if test "x$rewritten_target" = x; then
19601       rewritten_target=${OPENJDK_TARGET_AUTOCONF_NAME}
19602       echo Target stays the same $rewritten_target
19603     else
19604       echo Rewriting target for builddeps into $rewritten_target
19605     fi
19606     rewritten_build_var=`echo ${rewritten_build} | tr '-' '_' | tr '.' '_'`
19607     rewritten_target_var=`echo ${rewritten_target} | tr '-' '_' | tr '.' '_'`
19608   fi
19609   for ac_prog in 7z unzip
19610 do
19611   # Extract the first word of "$ac_prog", so it can be a program name with args.
19612 set dummy $ac_prog; ac_word=$2
19613 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19614 $as_echo_n "checking for $ac_word... " >&6; }
19615 if ${ac_cv_prog_BDEPS_UNZIP+:} false; then :
19616   $as_echo_n "(cached) " >&6
19617 else
19618   if test -n "$BDEPS_UNZIP"; then
19619   ac_cv_prog_BDEPS_UNZIP="$BDEPS_UNZIP" # Let the user override the test.
19620 else
19621 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19622 for as_dir in $PATH
19623 do
19624   IFS=$as_save_IFS
19625   test -z "$as_dir" && as_dir=.
19626     for ac_exec_ext in '' $ac_executable_extensions; do
19627   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19628     ac_cv_prog_BDEPS_UNZIP="$ac_prog"
19629     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19630     break 2
19631   fi
19632 done
19633   done
19634 IFS=$as_save_IFS
19635 
19636 fi
19637 fi
19638 BDEPS_UNZIP=$ac_cv_prog_BDEPS_UNZIP
19639 if test -n "$BDEPS_UNZIP"; then
19640   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_UNZIP" >&5
19641 $as_echo "$BDEPS_UNZIP" >&6; }
19642 else
19643   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19644 $as_echo "no" >&6; }
19645 fi
19646 
19647 
19648   test -n "$BDEPS_UNZIP" && break
19649 done
19650 
19651   if test "x$BDEPS_UNZIP" = x7z; then
19652     BDEPS_UNZIP="7z x"
19653   fi
19654 
19655   for ac_prog in wget lftp ftp
19656 do
19657   # Extract the first word of "$ac_prog", so it can be a program name with args.
19658 set dummy $ac_prog; ac_word=$2
19659 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19660 $as_echo_n "checking for $ac_word... " >&6; }
19661 if ${ac_cv_prog_BDEPS_FTP+:} false; then :
19662   $as_echo_n "(cached) " >&6
19663 else
19664   if test -n "$BDEPS_FTP"; then
19665   ac_cv_prog_BDEPS_FTP="$BDEPS_FTP" # Let the user override the test.
19666 else
19667 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19668 for as_dir in $PATH
19669 do
19670   IFS=$as_save_IFS
19671   test -z "$as_dir" && as_dir=.
19672     for ac_exec_ext in '' $ac_executable_extensions; do
19673   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19674     ac_cv_prog_BDEPS_FTP="$ac_prog"
19675     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19676     break 2
19677   fi
19678 done
19679   done
19680 IFS=$as_save_IFS
19681 
19682 fi
19683 fi
19684 BDEPS_FTP=$ac_cv_prog_BDEPS_FTP
19685 if test -n "$BDEPS_FTP"; then
19686   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_FTP" >&5
19687 $as_echo "$BDEPS_FTP" >&6; }
19688 else
19689   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19690 $as_echo "no" >&6; }
19691 fi
19692 
19693 
19694   test -n "$BDEPS_FTP" && break
19695 done
19696 
19697 
19698 
19699 ###############################################################################
19700 #
19701 # Determine OpenJDK variants, options and version numbers.
19702 #
19703 ###############################################################################
19704 
19705 # We need build & target for this.
19706 
19707 
19708   ###############################################################################
19709   #
19710   # Should we build a JDK/JVM with headful support (ie a graphical ui)?
19711   # We always build headless support.
19712   #
19713   { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
19714 $as_echo_n "checking headful support... " >&6; }
19715   # Check whether --enable-headful was given.
19716 if test "${enable_headful+set}" = set; then :
19717   enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
19718 else
19719   SUPPORT_HEADFUL=yes
19720 fi
19721 
19722 
19723   SUPPORT_HEADLESS=yes
19724   BUILD_HEADLESS="BUILD_HEADLESS:=true"
19725 
19726   if test "x$SUPPORT_HEADFUL" = xyes; then
19727     # We are building both headful and headless.
19728     headful_msg="include support for both headful and headless"
19729   fi
19730 
19731   if test "x$SUPPORT_HEADFUL" = xno; then
19732     # Thus we are building headless only.
19733     BUILD_HEADLESS="BUILD_HEADLESS:=true"
19734     headful_msg="headless only"
19735   fi
19736 
19737   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
19738 $as_echo "$headful_msg" >&6; }
19739 
19740 
19741 
19742 
19743 
19744   # Control wether Hotspot runs Queens test after build.
19745   # Check whether --enable-hotspot-test-in-build was given.
19746 if test "${enable_hotspot_test_in_build+set}" = set; then :
19747   enableval=$enable_hotspot_test_in_build;
19748 else
19749   enable_hotspot_test_in_build=no
19750 fi
19751 
19752   if test "x$enable_hotspot_test_in_build" = "xyes"; then
19753     TEST_IN_BUILD=true
19754   else
19755     TEST_IN_BUILD=false
19756   fi
19757 
19758 
19759   ###############################################################################
19760   #
19761   # Choose cacerts source file
19762   #
19763 
19764 # Check whether --with-cacerts-file was given.
19765 if test "${with_cacerts_file+set}" = set; then :
19766   withval=$with_cacerts_file;
19767 fi
19768 
19769   if test "x$with_cacerts_file" != x; then
19770     CACERTS_FILE=$with_cacerts_file
19771   fi
19772 
19773 
19774   ###############################################################################
19775   #
19776   # Enable or disable unlimited crypto
19777   #
19778   # Check whether --enable-unlimited-crypto was given.
19779 if test "${enable_unlimited_crypto+set}" = set; then :
19780   enableval=$enable_unlimited_crypto;
19781 else
19782   enable_unlimited_crypto=no
19783 fi
19784 
19785   if test "x$enable_unlimited_crypto" = "xyes"; then
19786     UNLIMITED_CRYPTO=true
19787   else
19788     UNLIMITED_CRYPTO=false
19789   fi
19790 
19791 
19792   ###############################################################################
19793   #
19794   # Enable or disable the elliptic curve crypto implementation
19795   #
19796 
19797 
19798   ###############################################################################
19799   #
19800   # Compress jars
19801   #
19802   COMPRESS_JARS=false
19803 
19804 
19805 
19806   ###############################################################################
19807   #
19808   # Enable or disable JFR
19809   #
19810   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build JFR" >&5
19811 $as_echo_n "checking whether to build JFR... " >&6; }
19812   # Check whether --enable-jfr was given.
19813 if test "${enable_jfr+set}" = set; then :
19814   enableval=$enable_jfr;
19815 else
19816   enable_jfr=auto
19817 fi
19818 
19819   if test "x$enable_jfr" = "xno"; then
19820     ENABLE_JFR=false
19821   elif test "x$enable_jfr" = "xyes" -o "x$enable_jfr" = "xauto"; then
19822     if test "x$JVM_VARIANT_MINIMAL1" = "xtrue" -o "x$JVM_VARIANT_ZERO" = "xtrue"; then
19823       if test "x$enable_jfr" = "xyes"; then
19824         as_fn_error $? "cannot enable JFR on minimal1 VM or zero build" "$LINENO" 5
19825       else
19826         ENABLE_JFR=false
19827       fi
19828     elif test "x$OPENJDK_TARGET_OS" = xaix; then
19829       if test "x$enable_jfr" = "xyes"; then
19830         as_fn_error $? "AIX does not support JFR" "$LINENO" 5
19831       else
19832         ENABLE_JFR=false
19833       fi
19834     else
19835       ENABLE_JFR=true
19836     fi
19837   else
19838     as_fn_error $? "--enable-jfr must be set to either yes or no" "$LINENO" 5
19839   fi
19840   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_JFR" >&5
19841 $as_echo "$ENABLE_JFR" >&6; }
19842 
19843 
19844 
19845   # Source the version numbers
19846   . $AUTOCONF_DIR/version-numbers
19847 
19848   # Get the settings from parameters
19849 
19850 # Check whether --with-milestone was given.
19851 if test "${with_milestone+set}" = set; then :
19852   withval=$with_milestone;
19853 fi
19854 
19855   if test "x$with_milestone" = xyes; then
19856     as_fn_error $? "Milestone must have a value" "$LINENO" 5
19857   elif test "x$with_milestone" != x; then
19858     MILESTONE="$with_milestone"
19859   fi
19860   if test "x$MILESTONE" = x; then
19861     MILESTONE=internal
19862   fi
19863 
19864 
19865 # Check whether --with-update-version was given.
19866 if test "${with_update_version+set}" = set; then :
19867   withval=$with_update_version;
19868 fi
19869 
19870   if test "x$with_update_version" = xyes; then
19871     as_fn_error $? "Update version must have a value" "$LINENO" 5
19872   elif test "x$with_update_version" != x; then
19873     JDK_UPDATE_VERSION="$with_update_version"
19874     # On macosx 10.7, it's not possible to set --with-update-version=0X due
19875     # to a bug in expr (which reduces it to just X). To work around this, we
19876     # always add a 0 to one digit update versions.
19877     if test "${#JDK_UPDATE_VERSION}" = "1"; then
19878       JDK_UPDATE_VERSION="0${JDK_UPDATE_VERSION}"
19879     fi
19880   fi
19881 
19882 
19883 # Check whether --with-user-release-suffix was given.
19884 if test "${with_user_release_suffix+set}" = set; then :
19885   withval=$with_user_release_suffix;
19886 fi
19887 
19888   if test "x$with_user_release_suffix" = xyes; then
19889     as_fn_error $? "Release suffix must have a value" "$LINENO" 5
19890   elif test "x$with_user_release_suffix" != x; then
19891     USER_RELEASE_SUFFIX="$with_user_release_suffix"
19892   fi
19893 
19894 
19895 # Check whether --with-build-number was given.
19896 if test "${with_build_number+set}" = set; then :
19897   withval=$with_build_number;
19898 fi
19899 
19900   if test "x$with_build_number" = xyes; then
19901     as_fn_error $? "Build number must have a value" "$LINENO" 5
19902   elif test "x$with_build_number" != x; then
19903     JDK_BUILD_NUMBER="$with_build_number"
19904   fi
19905   # Define default USER_RELEASE_SUFFIX if BUILD_NUMBER and USER_RELEASE_SUFFIX are not set
19906   if test "x$JDK_BUILD_NUMBER" = x; then
19907     JDK_BUILD_NUMBER=b00
19908     if test "x$USER_RELEASE_SUFFIX" = x; then
19909       BUILD_DATE=`date '+%Y_%m_%d_%H_%M'`
19910       # Avoid [:alnum:] since it depends on the locale.
19911       CLEAN_USERNAME=`echo "$USER" | $TR -d -c 'abcdefghijklmnopqrstuvqxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'`
19912       USER_RELEASE_SUFFIX=`echo "${CLEAN_USERNAME}_${BUILD_DATE}" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
19913     fi
19914   fi
19915 
19916   # Now set the JDK version, milestone, build number etc.
19917 
19918 
19919 
19920 
19921 
19922 
19923 
19924 
19925 
19926 
19927 
19928 
19929 
19930 
19931   # The vendor name, if any
19932 
19933 # Check whether --with-vendor-name was given.
19934 if test "${with_vendor_name+set}" = set; then :
19935   withval=$with_vendor_name;
19936 fi
19937 
19938   if test "x$with_vendor_name" = xyes; then
19939     as_fn_error $? "--with-vendor-name must have a value" "$LINENO" 5
19940   elif  ! [[ $with_vendor_name =~ ^[[:print:]]*$ ]] ; then
19941     as_fn_error $? "--with-vendor-name contains non-printing characters: $with_vendor_name" "$LINENO" 5
19942   elif test "x$with_vendor_name" != x; then
19943     # Only set COMPANY_NAME if '--with-vendor-name' was used and is not empty.
19944     # Otherwise we will use the value from "version-numbers" included above.
19945     COMPANY_NAME="$with_vendor_name"
19946   fi
19947 
19948 
19949   # The vendor URL, if any
19950 
19951 # Check whether --with-vendor-url was given.
19952 if test "${with_vendor_url+set}" = set; then :
19953   withval=$with_vendor_url;
19954 fi
19955 
19956   if test "x$with_vendor_url" = xyes; then
19957     as_fn_error $? "--with-vendor-url must have a value" "$LINENO" 5
19958   elif  ! [[ $with_vendor_url =~ ^[[:print:]]*$ ]] ; then
19959     as_fn_error $? "--with-vendor-url contains non-printing characters: $with_vendor_url" "$LINENO" 5
19960   else
19961     VENDOR_URL="$with_vendor_url"
19962   fi
19963 
19964 
19965   # The vendor bug URL, if any
19966 
19967 # Check whether --with-vendor-bug-url was given.
19968 if test "${with_vendor_bug_url+set}" = set; then :
19969   withval=$with_vendor_bug_url;
19970 fi
19971 
19972   if test "x$with_vendor_bug_url" = xyes; then
19973     as_fn_error $? "--with-vendor-bug-url must have a value" "$LINENO" 5
19974   elif  ! [[ $with_vendor_bug_url =~ ^[[:print:]]*$ ]] ; then
19975     as_fn_error $? "--with-vendor-bug-url contains non-printing characters: $with_vendor_bug_url" "$LINENO" 5
19976   else
19977     VENDOR_URL_BUG="$with_vendor_bug_url"
19978   fi
19979 
19980 
19981   # The vendor VM bug URL, if any
19982 
19983 # Check whether --with-vendor-vm-bug-url was given.
19984 if test "${with_vendor_vm_bug_url+set}" = set; then :
19985   withval=$with_vendor_vm_bug_url;
19986 fi
19987 
19988   if test "x$with_vendor_vm_bug_url" = xyes; then
19989     as_fn_error $? "--with-vendor-vm-bug-url must have a value" "$LINENO" 5
19990   elif  ! [[ $with_vendor_vm_bug_url =~ ^[[:print:]]*$ ]] ; then
19991     as_fn_error $? "--with-vendor-vm-bug-url contains non-printing characters: $with_vendor_vm_bug_url" "$LINENO" 5
19992   else
19993     VENDOR_URL_VM_BUG="$with_vendor_vm_bug_url"
19994   fi
19995 
19996 
19997 
19998 # Check whether --with-copyright-year was given.
19999 if test "${with_copyright_year+set}" = set; then :
20000   withval=$with_copyright_year;
20001 fi
20002 
20003   if test "x$with_copyright_year" = xyes; then
20004     as_fn_error $? "Copyright year must have a value" "$LINENO" 5
20005   elif test "x$with_copyright_year" != x; then
20006     COPYRIGHT_YEAR="$with_copyright_year"
20007   else
20008     COPYRIGHT_YEAR=`date +'%Y'`
20009   fi
20010 
20011 
20012   if test "x$JDK_UPDATE_VERSION" != x; then
20013     JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}_${JDK_UPDATE_VERSION}"
20014   else
20015     JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}"
20016   fi
20017 
20018 
20019   # The cooked update version used to encode trailing letters in the update
20020   # version into a trailing number. That is no longer needed, but need to
20021   # keep the format in 8u for compatibility.
20022   COOKED_JDK_UPDATE_VERSION="${JDK_UPDATE_VERSION}0"
20023 
20024 
20025   COOKED_BUILD_NUMBER=`$ECHO $JDK_BUILD_NUMBER | $SED -e 's/^b//' -e 's/^0//'`
20026 
20027 
20028 
20029 ###############################################################################
20030 #
20031 # Setup BootJDK, used to bootstrap the build.
20032 #
20033 ###############################################################################
20034 
20035 
20036   BOOT_JDK_FOUND=no
20037 
20038 # Check whether --with-boot-jdk was given.
20039 if test "${with_boot_jdk+set}" = set; then :
20040   withval=$with_boot_jdk;
20041 fi
20042 
20043 
20044   # We look for the Boot JDK through various means, going from more certain to
20045   # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
20046   # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
20047   # must check if this is indeed valid; otherwise we'll continue looking.
20048 
20049   # Test: Is bootjdk explicitely set by command line arguments?
20050 
20051   if test "x$BOOT_JDK_FOUND" = xno; then
20052     # Now execute the test
20053 
20054   if test "x$with_boot_jdk" != x; then
20055     BOOT_JDK=$with_boot_jdk
20056     BOOT_JDK_FOUND=maybe
20057     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
20058 $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
20059   fi
20060 
20061 
20062     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20063     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20064       # Do we have a bin/java?
20065       if test ! -x "$BOOT_JDK/bin/java"; then
20066         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20067 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20068         BOOT_JDK_FOUND=no
20069       else
20070         # Do we have a bin/javac?
20071         if test ! -x "$BOOT_JDK/bin/javac"; then
20072           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20073 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20074           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20075 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20076           BOOT_JDK_FOUND=no
20077         else
20078           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20079           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20080             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20081 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20082             BOOT_JDK_FOUND=no
20083           else
20084             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20085             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20086 
20087             # Extra M4 quote needed to protect [] in grep expression.
20088             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
20089             if test "x$FOUND_VERSION_78" = x; then
20090               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20091 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20092               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
20093 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
20094               BOOT_JDK_FOUND=no
20095             else
20096               # We're done! :-)
20097               BOOT_JDK_FOUND=yes
20098 
20099   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20100 
20101   # Input might be given as Windows format, start by converting to
20102   # unix format.
20103   path="$BOOT_JDK"
20104   new_path=`$CYGPATH -u "$path"`
20105 
20106   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20107   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20108   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20109   # "foo.exe" is OK but "foo" is an error.
20110   #
20111   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20112   # It is also a way to make sure we got the proper file name for the real test later on.
20113   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20114   if test "x$test_shortpath" = x; then
20115     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20116 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20117     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20118   fi
20119 
20120   # Call helper function which possibly converts this using DOS-style short mode.
20121   # If so, the updated path is stored in $new_path.
20122 
20123   input_path="$new_path"
20124   # Check if we need to convert this using DOS-style short mode. If the path
20125   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20126   # take no chances and rewrite it.
20127   # Note: m4 eats our [], so we need to use [ and ] instead.
20128   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20129   if test "x$has_forbidden_chars" != x; then
20130     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20131     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20132     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20133     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20134       # Going to short mode and back again did indeed matter. Since short mode is
20135       # case insensitive, let's make it lowercase to improve readability.
20136       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20137       # Now convert it back to Unix-style (cygpath)
20138       input_path=`$CYGPATH -u "$shortmode_path"`
20139       new_path="$input_path"
20140     fi
20141   fi
20142 
20143   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20144   if test "x$test_cygdrive_prefix" = x; then
20145     # As a simple fix, exclude /usr/bin since it's not a real path.
20146     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20147       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20148       # a path prefixed by /cygdrive for fixpath to work.
20149       new_path="$CYGWIN_ROOT_PATH$input_path"
20150     fi
20151   fi
20152 
20153 
20154   if test "x$path" != "x$new_path"; then
20155     BOOT_JDK="$new_path"
20156     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20157 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20158   fi
20159 
20160   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20161 
20162   path="$BOOT_JDK"
20163   has_colon=`$ECHO $path | $GREP ^.:`
20164   new_path="$path"
20165   if test "x$has_colon" = x; then
20166     # Not in mixed or Windows style, start by that.
20167     new_path=`cmd //c echo $path`
20168   fi
20169 
20170 
20171   input_path="$new_path"
20172   # Check if we need to convert this using DOS-style short mode. If the path
20173   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20174   # take no chances and rewrite it.
20175   # Note: m4 eats our [], so we need to use [ and ] instead.
20176   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20177   if test "x$has_forbidden_chars" != x; then
20178     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20179     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20180   fi
20181 
20182 
20183   windows_path="$new_path"
20184   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20185     unix_path=`$CYGPATH -u "$windows_path"`
20186     new_path="$unix_path"
20187   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20188     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20189     new_path="$unix_path"
20190   fi
20191 
20192   if test "x$path" != "x$new_path"; then
20193     BOOT_JDK="$new_path"
20194     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20195 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20196   fi
20197 
20198   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20199   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20200 
20201   else
20202     # We're on a posix platform. Hooray! :)
20203     path="$BOOT_JDK"
20204     has_space=`$ECHO "$path" | $GREP " "`
20205     if test "x$has_space" != x; then
20206       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20207 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20208       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20209     fi
20210 
20211     # Use eval to expand a potential ~
20212     eval path="$path"
20213     if test ! -f "$path" && test ! -d "$path"; then
20214       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20215     fi
20216 
20217     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20218   fi
20219 
20220               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20221 $as_echo_n "checking for Boot JDK... " >&6; }
20222               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20223 $as_echo "$BOOT_JDK" >&6; }
20224               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20225 $as_echo_n "checking Boot JDK version... " >&6; }
20226               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20227               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20228 $as_echo "$BOOT_JDK_VERSION" >&6; }
20229             fi # end check jdk version
20230           fi # end check rt.jar
20231         fi # end check javac
20232       fi # end check java
20233     fi # end check boot jdk found
20234   fi
20235 
20236   if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
20237     # Having specified an argument which is incorrect will produce an instant failure;
20238     # we should not go on looking
20239     as_fn_error $? "The path given by --with-boot-jdk does not contain a valid Boot JDK" "$LINENO" 5
20240   fi
20241 
20242   # Test: Is bootjdk available from builddeps?
20243 
20244   if test "x$BOOT_JDK_FOUND" = xno; then
20245     # Now execute the test
20246 
20247 
20248 
20249   if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
20250     # Source the builddeps file again, to make sure it uses the latest variables!
20251     . $builddepsfile
20252     # Look for a target and build machine specific resource!
20253     eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}_TARGET_${rewritten_target_var}}
20254     if test "x$resource" = x; then
20255       # Ok, lets instead look for a target specific resource
20256       eval resource=\${builddep_bootjdk_TARGET_${rewritten_target_var}}
20257     fi
20258     if test "x$resource" = x; then
20259       # Ok, lets instead look for a build specific resource
20260       eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}}
20261     fi
20262     if test "x$resource" = x; then
20263       # Ok, lets instead look for a generic resource
20264       # (The bootjdk comes from M4 and not the shell, thus no need for eval here.)
20265       resource=${builddep_bootjdk}
20266     fi
20267     if test "x$resource" != x; then
20268       { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for bootjdk" >&5
20269 $as_echo "$as_me: Using builddeps $resource for bootjdk" >&6;}
20270       # If the resource in the builddeps.conf file is an existing directory,
20271       # for example /java/linux/cups
20272       if test -d ${resource}; then
20273         depdir=${resource}
20274       else
20275 
20276   # bootjdk is for example mymodule
20277   # $resource is for example libs/general/libmymod_1_2_3.zip
20278   # $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps
20279   # $with_builddeps_dir is for example /localhome/builddeps
20280   # depdir is the name of the variable into which we store the depdir, eg MYMOD
20281   # Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and
20282   # unzip into the directory: /localhome/builddeps/libmymod_1_2_3
20283   filename=`basename $resource`
20284   filebase=`echo $filename | sed 's/\.[^\.]*$//'`
20285   filebase=${filename%%.*}
20286   extension=${filename#*.}
20287   installdir=$with_builddeps_dir/$filebase
20288   if test ! -f $installdir/$filename.unpacked; then
20289     { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&5
20290 $as_echo "$as_me: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&6;}
20291     if test ! -d $installdir; then
20292       mkdir -p $installdir
20293     fi
20294     if test ! -d $installdir; then
20295       as_fn_error $? "Could not create directory $installdir" "$LINENO" 5
20296     fi
20297     tmpfile=`mktemp $installdir/bootjdk.XXXXXXXXX`
20298     touch $tmpfile
20299     if test ! -f $tmpfile; then
20300       as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5
20301     fi
20302 
20303   # $with_builddeps_server/$resource  is the ftp://abuilddeps.server.com/libs/cups.zip
20304   # $tmpfile is the local file name for the downloaded file.
20305   VALID_TOOL=no
20306   if test "x$BDEPS_FTP" = xwget; then
20307     VALID_TOOL=yes
20308     wget -O $tmpfile $with_builddeps_server/$resource
20309   fi
20310   if test "x$BDEPS_FTP" = xlftp; then
20311     VALID_TOOL=yes
20312     lftp -c "get $with_builddeps_server/$resource  -o $tmpfile"
20313   fi
20314   if test "x$BDEPS_FTP" = xftp; then
20315     VALID_TOOL=yes
20316     FTPSERVER=`echo $with_builddeps_server/$resource  | cut -f 3 -d '/'`
20317     FTPPATH=`echo $with_builddeps_server/$resource  | cut -f 4- -d '/'`
20318     FTPUSERPWD=${FTPSERVER%%@*}
20319     if test "x$FTPSERVER" != "x$FTPUSERPWD"; then
20320       FTPUSER=${userpwd%%:*}
20321       FTPPWD=${userpwd#*@}
20322       FTPSERVER=${FTPSERVER#*@}
20323     else
20324       FTPUSER=ftp
20325       FTPPWD=ftp
20326     fi
20327     # the "pass" command does not work on some
20328     # ftp clients (read ftp.exe) but if it works,
20329     # passive mode is better!
20330     ( \
20331         echo "user $FTPUSER $FTPPWD"        ; \
20332         echo "pass"                         ; \
20333         echo "bin"                          ; \
20334         echo "get $FTPPATH $tmpfile"              ; \
20335     ) | ftp -in $FTPSERVER
20336   fi
20337   if test "x$VALID_TOOL" != xyes; then
20338     as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5
20339   fi
20340 
20341     mv $tmpfile $installdir/$filename
20342     if test ! -s $installdir/$filename; then
20343       as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5
20344     fi
20345     case "$extension" in
20346       zip)  echo "Unzipping $installdir/$filename..."
20347         (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked)
20348         ;;
20349       tar.gz) echo "Untaring $installdir/$filename..."
20350         (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
20351         ;;
20352       tgz) echo "Untaring $installdir/$filename..."
20353         (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
20354         ;;
20355       *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5
20356         ;;
20357     esac
20358   fi
20359   if test -f $installdir/$filename.unpacked; then
20360     depdir=$installdir
20361   fi
20362 
20363       fi
20364       # Source the builddeps file again, because in the previous command, the depdir
20365       # was updated to point at the current build dependency install directory.
20366       . $builddepsfile
20367       # Now extract variables from the builddeps.conf files.
20368       theroot=${builddep_bootjdk_ROOT}
20369       thecflags=${builddep_bootjdk_CFLAGS}
20370       thelibs=${builddep_bootjdk_LIBS}
20371       if test "x$depdir" = x; then
20372         as_fn_error $? "Could not download build dependency bootjdk" "$LINENO" 5
20373       fi
20374       BOOT_JDK=$depdir
20375       if test "x$theroot" != x; then
20376         BOOT_JDK="$theroot"
20377       fi
20378       if test "x$thecflags" != x; then
20379         BOOT_JDK_CFLAGS="$thecflags"
20380       fi
20381       if test "x$thelibs" != x; then
20382         BOOT_JDK_LIBS="$thelibs"
20383       fi
20384       BOOT_JDK_FOUND=maybe
20385       else BOOT_JDK_FOUND=no
20386 
20387     fi
20388     else BOOT_JDK_FOUND=no
20389 
20390   fi
20391 
20392 
20393 
20394     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20395     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20396       # Do we have a bin/java?
20397       if test ! -x "$BOOT_JDK/bin/java"; then
20398         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20399 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20400         BOOT_JDK_FOUND=no
20401       else
20402         # Do we have a bin/javac?
20403         if test ! -x "$BOOT_JDK/bin/javac"; then
20404           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20405 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20406           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20407 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20408           BOOT_JDK_FOUND=no
20409         else
20410           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20411           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20412             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20413 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20414             BOOT_JDK_FOUND=no
20415           else
20416             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20417             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20418 
20419             # Extra M4 quote needed to protect [] in grep expression.
20420             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
20421             if test "x$FOUND_VERSION_78" = x; then
20422               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20423 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20424               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
20425 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
20426               BOOT_JDK_FOUND=no
20427             else
20428               # We're done! :-)
20429               BOOT_JDK_FOUND=yes
20430 
20431   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20432 
20433   # Input might be given as Windows format, start by converting to
20434   # unix format.
20435   path="$BOOT_JDK"
20436   new_path=`$CYGPATH -u "$path"`
20437 
20438   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20439   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20440   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20441   # "foo.exe" is OK but "foo" is an error.
20442   #
20443   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20444   # It is also a way to make sure we got the proper file name for the real test later on.
20445   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20446   if test "x$test_shortpath" = x; then
20447     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20448 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20449     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20450   fi
20451 
20452   # Call helper function which possibly converts this using DOS-style short mode.
20453   # If so, the updated path is stored in $new_path.
20454 
20455   input_path="$new_path"
20456   # Check if we need to convert this using DOS-style short mode. If the path
20457   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20458   # take no chances and rewrite it.
20459   # Note: m4 eats our [], so we need to use [ and ] instead.
20460   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20461   if test "x$has_forbidden_chars" != x; then
20462     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20463     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20464     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20465     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20466       # Going to short mode and back again did indeed matter. Since short mode is
20467       # case insensitive, let's make it lowercase to improve readability.
20468       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20469       # Now convert it back to Unix-style (cygpath)
20470       input_path=`$CYGPATH -u "$shortmode_path"`
20471       new_path="$input_path"
20472     fi
20473   fi
20474 
20475   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20476   if test "x$test_cygdrive_prefix" = x; then
20477     # As a simple fix, exclude /usr/bin since it's not a real path.
20478     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20479       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20480       # a path prefixed by /cygdrive for fixpath to work.
20481       new_path="$CYGWIN_ROOT_PATH$input_path"
20482     fi
20483   fi
20484 
20485 
20486   if test "x$path" != "x$new_path"; then
20487     BOOT_JDK="$new_path"
20488     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20489 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20490   fi
20491 
20492   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20493 
20494   path="$BOOT_JDK"
20495   has_colon=`$ECHO $path | $GREP ^.:`
20496   new_path="$path"
20497   if test "x$has_colon" = x; then
20498     # Not in mixed or Windows style, start by that.
20499     new_path=`cmd //c echo $path`
20500   fi
20501 
20502 
20503   input_path="$new_path"
20504   # Check if we need to convert this using DOS-style short mode. If the path
20505   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20506   # take no chances and rewrite it.
20507   # Note: m4 eats our [], so we need to use [ and ] instead.
20508   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20509   if test "x$has_forbidden_chars" != x; then
20510     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20511     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20512   fi
20513 
20514 
20515   windows_path="$new_path"
20516   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20517     unix_path=`$CYGPATH -u "$windows_path"`
20518     new_path="$unix_path"
20519   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20520     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20521     new_path="$unix_path"
20522   fi
20523 
20524   if test "x$path" != "x$new_path"; then
20525     BOOT_JDK="$new_path"
20526     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20527 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20528   fi
20529 
20530   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20531   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20532 
20533   else
20534     # We're on a posix platform. Hooray! :)
20535     path="$BOOT_JDK"
20536     has_space=`$ECHO "$path" | $GREP " "`
20537     if test "x$has_space" != x; then
20538       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20539 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20540       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20541     fi
20542 
20543     # Use eval to expand a potential ~
20544     eval path="$path"
20545     if test ! -f "$path" && test ! -d "$path"; then
20546       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20547     fi
20548 
20549     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20550   fi
20551 
20552               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20553 $as_echo_n "checking for Boot JDK... " >&6; }
20554               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20555 $as_echo "$BOOT_JDK" >&6; }
20556               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20557 $as_echo_n "checking Boot JDK version... " >&6; }
20558               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20559               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20560 $as_echo "$BOOT_JDK_VERSION" >&6; }
20561             fi # end check jdk version
20562           fi # end check rt.jar
20563         fi # end check javac
20564       fi # end check java
20565     fi # end check boot jdk found
20566   fi
20567 
20568 
20569   # Test: Is $JAVA_HOME set?
20570 
20571   if test "x$BOOT_JDK_FOUND" = xno; then
20572     # Now execute the test
20573 
20574   if test "x$JAVA_HOME" != x; then
20575     JAVA_HOME_PROCESSED="$JAVA_HOME"
20576 
20577   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20578 
20579   # Input might be given as Windows format, start by converting to
20580   # unix format.
20581   path="$JAVA_HOME_PROCESSED"
20582   new_path=`$CYGPATH -u "$path"`
20583 
20584   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20585   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20586   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20587   # "foo.exe" is OK but "foo" is an error.
20588   #
20589   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20590   # It is also a way to make sure we got the proper file name for the real test later on.
20591   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20592   if test "x$test_shortpath" = x; then
20593     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
20594 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
20595     as_fn_error $? "Cannot locate the the path of JAVA_HOME_PROCESSED" "$LINENO" 5
20596   fi
20597 
20598   # Call helper function which possibly converts this using DOS-style short mode.
20599   # If so, the updated path is stored in $new_path.
20600 
20601   input_path="$new_path"
20602   # Check if we need to convert this using DOS-style short mode. If the path
20603   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20604   # take no chances and rewrite it.
20605   # Note: m4 eats our [], so we need to use [ and ] instead.
20606   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20607   if test "x$has_forbidden_chars" != x; then
20608     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20609     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20610     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20611     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20612       # Going to short mode and back again did indeed matter. Since short mode is
20613       # case insensitive, let's make it lowercase to improve readability.
20614       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20615       # Now convert it back to Unix-style (cygpath)
20616       input_path=`$CYGPATH -u "$shortmode_path"`
20617       new_path="$input_path"
20618     fi
20619   fi
20620 
20621   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20622   if test "x$test_cygdrive_prefix" = x; then
20623     # As a simple fix, exclude /usr/bin since it's not a real path.
20624     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20625       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20626       # a path prefixed by /cygdrive for fixpath to work.
20627       new_path="$CYGWIN_ROOT_PATH$input_path"
20628     fi
20629   fi
20630 
20631 
20632   if test "x$path" != "x$new_path"; then
20633     JAVA_HOME_PROCESSED="$new_path"
20634     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
20635 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
20636   fi
20637 
20638   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20639 
20640   path="$JAVA_HOME_PROCESSED"
20641   has_colon=`$ECHO $path | $GREP ^.:`
20642   new_path="$path"
20643   if test "x$has_colon" = x; then
20644     # Not in mixed or Windows style, start by that.
20645     new_path=`cmd //c echo $path`
20646   fi
20647 
20648 
20649   input_path="$new_path"
20650   # Check if we need to convert this using DOS-style short mode. If the path
20651   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20652   # take no chances and rewrite it.
20653   # Note: m4 eats our [], so we need to use [ and ] instead.
20654   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20655   if test "x$has_forbidden_chars" != x; then
20656     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20657     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20658   fi
20659 
20660 
20661   windows_path="$new_path"
20662   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20663     unix_path=`$CYGPATH -u "$windows_path"`
20664     new_path="$unix_path"
20665   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20666     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20667     new_path="$unix_path"
20668   fi
20669 
20670   if test "x$path" != "x$new_path"; then
20671     JAVA_HOME_PROCESSED="$new_path"
20672     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
20673 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
20674   fi
20675 
20676   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20677   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20678 
20679   else
20680     # We're on a posix platform. Hooray! :)
20681     path="$JAVA_HOME_PROCESSED"
20682     has_space=`$ECHO "$path" | $GREP " "`
20683     if test "x$has_space" != x; then
20684       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
20685 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
20686       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20687     fi
20688 
20689     # Use eval to expand a potential ~
20690     eval path="$path"
20691     if test ! -f "$path" && test ! -d "$path"; then
20692       as_fn_error $? "The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is not found." "$LINENO" 5
20693     fi
20694 
20695     JAVA_HOME_PROCESSED="`cd "$path"; $THEPWDCMD -L`"
20696   fi
20697 
20698     if test ! -d "$JAVA_HOME_PROCESSED"; then
20699       { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
20700 $as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
20701     else
20702       # Aha, the user has set a JAVA_HOME
20703       # let us use that as the Boot JDK.
20704       BOOT_JDK="$JAVA_HOME_PROCESSED"
20705       BOOT_JDK_FOUND=maybe
20706       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using JAVA_HOME" >&5
20707 $as_echo "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
20708     fi
20709   fi
20710 
20711 
20712     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20713     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20714       # Do we have a bin/java?
20715       if test ! -x "$BOOT_JDK/bin/java"; then
20716         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20717 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20718         BOOT_JDK_FOUND=no
20719       else
20720         # Do we have a bin/javac?
20721         if test ! -x "$BOOT_JDK/bin/javac"; then
20722           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20723 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20724           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20725 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20726           BOOT_JDK_FOUND=no
20727         else
20728           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20729           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20730             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20731 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20732             BOOT_JDK_FOUND=no
20733           else
20734             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20735             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20736 
20737             # Extra M4 quote needed to protect [] in grep expression.
20738             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
20739             if test "x$FOUND_VERSION_78" = x; then
20740               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20741 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20742               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
20743 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
20744               BOOT_JDK_FOUND=no
20745             else
20746               # We're done! :-)
20747               BOOT_JDK_FOUND=yes
20748 
20749   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20750 
20751   # Input might be given as Windows format, start by converting to
20752   # unix format.
20753   path="$BOOT_JDK"
20754   new_path=`$CYGPATH -u "$path"`
20755 
20756   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20757   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20758   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20759   # "foo.exe" is OK but "foo" is an error.
20760   #
20761   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20762   # It is also a way to make sure we got the proper file name for the real test later on.
20763   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20764   if test "x$test_shortpath" = x; then
20765     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20766 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20767     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20768   fi
20769 
20770   # Call helper function which possibly converts this using DOS-style short mode.
20771   # If so, the updated path is stored in $new_path.
20772 
20773   input_path="$new_path"
20774   # Check if we need to convert this using DOS-style short mode. If the path
20775   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20776   # take no chances and rewrite it.
20777   # Note: m4 eats our [], so we need to use [ and ] instead.
20778   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20779   if test "x$has_forbidden_chars" != x; then
20780     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20781     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20782     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20783     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20784       # Going to short mode and back again did indeed matter. Since short mode is
20785       # case insensitive, let's make it lowercase to improve readability.
20786       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20787       # Now convert it back to Unix-style (cygpath)
20788       input_path=`$CYGPATH -u "$shortmode_path"`
20789       new_path="$input_path"
20790     fi
20791   fi
20792 
20793   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20794   if test "x$test_cygdrive_prefix" = x; then
20795     # As a simple fix, exclude /usr/bin since it's not a real path.
20796     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20797       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20798       # a path prefixed by /cygdrive for fixpath to work.
20799       new_path="$CYGWIN_ROOT_PATH$input_path"
20800     fi
20801   fi
20802 
20803 
20804   if test "x$path" != "x$new_path"; then
20805     BOOT_JDK="$new_path"
20806     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20807 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20808   fi
20809 
20810   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20811 
20812   path="$BOOT_JDK"
20813   has_colon=`$ECHO $path | $GREP ^.:`
20814   new_path="$path"
20815   if test "x$has_colon" = x; then
20816     # Not in mixed or Windows style, start by that.
20817     new_path=`cmd //c echo $path`
20818   fi
20819 
20820 
20821   input_path="$new_path"
20822   # Check if we need to convert this using DOS-style short mode. If the path
20823   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20824   # take no chances and rewrite it.
20825   # Note: m4 eats our [], so we need to use [ and ] instead.
20826   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20827   if test "x$has_forbidden_chars" != x; then
20828     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20829     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20830   fi
20831 
20832 
20833   windows_path="$new_path"
20834   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20835     unix_path=`$CYGPATH -u "$windows_path"`
20836     new_path="$unix_path"
20837   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20838     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20839     new_path="$unix_path"
20840   fi
20841 
20842   if test "x$path" != "x$new_path"; then
20843     BOOT_JDK="$new_path"
20844     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20845 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20846   fi
20847 
20848   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20849   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20850 
20851   else
20852     # We're on a posix platform. Hooray! :)
20853     path="$BOOT_JDK"
20854     has_space=`$ECHO "$path" | $GREP " "`
20855     if test "x$has_space" != x; then
20856       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20857 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20858       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20859     fi
20860 
20861     # Use eval to expand a potential ~
20862     eval path="$path"
20863     if test ! -f "$path" && test ! -d "$path"; then
20864       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20865     fi
20866 
20867     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20868   fi
20869 
20870               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20871 $as_echo_n "checking for Boot JDK... " >&6; }
20872               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20873 $as_echo "$BOOT_JDK" >&6; }
20874               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20875 $as_echo_n "checking Boot JDK version... " >&6; }
20876               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20877               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20878 $as_echo "$BOOT_JDK_VERSION" >&6; }
20879             fi # end check jdk version
20880           fi # end check rt.jar
20881         fi # end check javac
20882       fi # end check java
20883     fi # end check boot jdk found
20884   fi
20885 
20886 
20887   # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
20888 
20889   if test "x$BOOT_JDK_FOUND" = xno; then
20890     # Now execute the test
20891 
20892   if test -x /usr/libexec/java_home; then
20893     BOOT_JDK=`/usr/libexec/java_home`
20894     BOOT_JDK_FOUND=maybe
20895     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home" >&5
20896 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home" >&6;}
20897   fi
20898 
20899 
20900     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20901     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20902       # Do we have a bin/java?
20903       if test ! -x "$BOOT_JDK/bin/java"; then
20904         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20905 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20906         BOOT_JDK_FOUND=no
20907       else
20908         # Do we have a bin/javac?
20909         if test ! -x "$BOOT_JDK/bin/javac"; then
20910           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20911 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20912           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20913 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20914           BOOT_JDK_FOUND=no
20915         else
20916           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
20917           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
20918             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
20919 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
20920             BOOT_JDK_FOUND=no
20921           else
20922             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20923             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20924 
20925             # Extra M4 quote needed to protect [] in grep expression.
20926             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
20927             if test "x$FOUND_VERSION_78" = x; then
20928               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20929 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20930               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
20931 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
20932               BOOT_JDK_FOUND=no
20933             else
20934               # We're done! :-)
20935               BOOT_JDK_FOUND=yes
20936 
20937   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20938 
20939   # Input might be given as Windows format, start by converting to
20940   # unix format.
20941   path="$BOOT_JDK"
20942   new_path=`$CYGPATH -u "$path"`
20943 
20944   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20945   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20946   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20947   # "foo.exe" is OK but "foo" is an error.
20948   #
20949   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20950   # It is also a way to make sure we got the proper file name for the real test later on.
20951   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20952   if test "x$test_shortpath" = x; then
20953     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20954 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20955     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20956   fi
20957 
20958   # Call helper function which possibly converts this using DOS-style short mode.
20959   # If so, the updated path is stored in $new_path.
20960 
20961   input_path="$new_path"
20962   # Check if we need to convert this using DOS-style short mode. If the path
20963   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20964   # take no chances and rewrite it.
20965   # Note: m4 eats our [], so we need to use [ and ] instead.
20966   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20967   if test "x$has_forbidden_chars" != x; then
20968     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20969     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20970     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20971     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20972       # Going to short mode and back again did indeed matter. Since short mode is
20973       # case insensitive, let's make it lowercase to improve readability.
20974       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20975       # Now convert it back to Unix-style (cygpath)
20976       input_path=`$CYGPATH -u "$shortmode_path"`
20977       new_path="$input_path"
20978     fi
20979   fi
20980 
20981   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20982   if test "x$test_cygdrive_prefix" = x; then
20983     # As a simple fix, exclude /usr/bin since it's not a real path.
20984     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20985       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20986       # a path prefixed by /cygdrive for fixpath to work.
20987       new_path="$CYGWIN_ROOT_PATH$input_path"
20988     fi
20989   fi
20990 
20991 
20992   if test "x$path" != "x$new_path"; then
20993     BOOT_JDK="$new_path"
20994     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20995 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20996   fi
20997 
20998   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20999 
21000   path="$BOOT_JDK"
21001   has_colon=`$ECHO $path | $GREP ^.:`
21002   new_path="$path"
21003   if test "x$has_colon" = x; then
21004     # Not in mixed or Windows style, start by that.
21005     new_path=`cmd //c echo $path`
21006   fi
21007 
21008 
21009   input_path="$new_path"
21010   # Check if we need to convert this using DOS-style short mode. If the path
21011   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21012   # take no chances and rewrite it.
21013   # Note: m4 eats our [], so we need to use [ and ] instead.
21014   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21015   if test "x$has_forbidden_chars" != x; then
21016     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21017     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21018   fi
21019 
21020 
21021   windows_path="$new_path"
21022   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21023     unix_path=`$CYGPATH -u "$windows_path"`
21024     new_path="$unix_path"
21025   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21026     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21027     new_path="$unix_path"
21028   fi
21029 
21030   if test "x$path" != "x$new_path"; then
21031     BOOT_JDK="$new_path"
21032     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21033 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21034   fi
21035 
21036   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21037   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21038 
21039   else
21040     # We're on a posix platform. Hooray! :)
21041     path="$BOOT_JDK"
21042     has_space=`$ECHO "$path" | $GREP " "`
21043     if test "x$has_space" != x; then
21044       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21045 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21046       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21047     fi
21048 
21049     # Use eval to expand a potential ~
21050     eval path="$path"
21051     if test ! -f "$path" && test ! -d "$path"; then
21052       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21053     fi
21054 
21055     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21056   fi
21057 
21058               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21059 $as_echo_n "checking for Boot JDK... " >&6; }
21060               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21061 $as_echo "$BOOT_JDK" >&6; }
21062               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21063 $as_echo_n "checking Boot JDK version... " >&6; }
21064               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21065               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21066 $as_echo "$BOOT_JDK_VERSION" >&6; }
21067             fi # end check jdk version
21068           fi # end check rt.jar
21069         fi # end check javac
21070       fi # end check java
21071     fi # end check boot jdk found
21072   fi
21073 
21074 
21075   # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
21076 
21077   if test "x$BOOT_JDK_FOUND" = xno; then
21078     # Now execute the test
21079 
21080   # Extract the first word of "javac", so it can be a program name with args.
21081 set dummy javac; ac_word=$2
21082 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21083 $as_echo_n "checking for $ac_word... " >&6; }
21084 if ${ac_cv_path_JAVAC_CHECK+:} false; then :
21085   $as_echo_n "(cached) " >&6
21086 else
21087   case $JAVAC_CHECK in
21088   [\\/]* | ?:[\\/]*)
21089   ac_cv_path_JAVAC_CHECK="$JAVAC_CHECK" # Let the user override the test with a path.
21090   ;;
21091   *)
21092   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21093 for as_dir in $PATH
21094 do
21095   IFS=$as_save_IFS
21096   test -z "$as_dir" && as_dir=.
21097     for ac_exec_ext in '' $ac_executable_extensions; do
21098   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21099     ac_cv_path_JAVAC_CHECK="$as_dir/$ac_word$ac_exec_ext"
21100     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21101     break 2
21102   fi
21103 done
21104   done
21105 IFS=$as_save_IFS
21106 
21107   ;;
21108 esac
21109 fi
21110 JAVAC_CHECK=$ac_cv_path_JAVAC_CHECK
21111 if test -n "$JAVAC_CHECK"; then
21112   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5
21113 $as_echo "$JAVAC_CHECK" >&6; }
21114 else
21115   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21116 $as_echo "no" >&6; }
21117 fi
21118 
21119 
21120   # Extract the first word of "java", so it can be a program name with args.
21121 set dummy java; ac_word=$2
21122 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21123 $as_echo_n "checking for $ac_word... " >&6; }
21124 if ${ac_cv_path_JAVA_CHECK+:} false; then :
21125   $as_echo_n "(cached) " >&6
21126 else
21127   case $JAVA_CHECK in
21128   [\\/]* | ?:[\\/]*)
21129   ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path.
21130   ;;
21131   *)
21132   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21133 for as_dir in $PATH
21134 do
21135   IFS=$as_save_IFS
21136   test -z "$as_dir" && as_dir=.
21137     for ac_exec_ext in '' $ac_executable_extensions; do
21138   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21139     ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext"
21140     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21141     break 2
21142   fi
21143 done
21144   done
21145 IFS=$as_save_IFS
21146 
21147   ;;
21148 esac
21149 fi
21150 JAVA_CHECK=$ac_cv_path_JAVA_CHECK
21151 if test -n "$JAVA_CHECK"; then
21152   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5
21153 $as_echo "$JAVA_CHECK" >&6; }
21154 else
21155   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21156 $as_echo "no" >&6; }
21157 fi
21158 
21159 
21160   BINARY="$JAVAC_CHECK"
21161   if test "x$JAVAC_CHECK" = x; then
21162     BINARY="$JAVA_CHECK"
21163   fi
21164   if test "x$BINARY" != x; then
21165     # So there is a java(c) binary, it might be part of a JDK.
21166     # Lets find the JDK/JRE directory by following symbolic links.
21167     # Linux/GNU systems often have links from /usr/bin/java to
21168     # /etc/alternatives/java to the real JDK binary.
21169 
21170   if test "x$OPENJDK_BUILD_OS" != xwindows; then
21171     # Follow a chain of symbolic links. Use readlink
21172     # where it exists, else fall back to horribly
21173     # complicated shell code.
21174     if test "x$READLINK_TESTED" != yes; then
21175       # On MacOSX there is a readlink tool with a different
21176       # purpose than the GNU readlink tool. Check the found readlink.
21177       ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
21178       if test "x$ISGNU" = x; then
21179         # A readlink that we do not know how to use.
21180         # Are there other non-GNU readlinks out there?
21181         READLINK_TESTED=yes
21182         READLINK=
21183       fi
21184     fi
21185 
21186     if test "x$READLINK" != x; then
21187       BINARY=`$READLINK -f $BINARY`
21188     else
21189       # Save the current directory for restoring afterwards
21190       STARTDIR=$PWD
21191       COUNTER=0
21192       sym_link_dir=`$DIRNAME $BINARY`
21193       sym_link_file=`$BASENAME $BINARY`
21194       cd $sym_link_dir
21195       # Use -P flag to resolve symlinks in directories.
21196       cd `$THEPWDCMD -P`
21197       sym_link_dir=`$THEPWDCMD -P`
21198       # Resolve file symlinks
21199       while test $COUNTER -lt 20; do
21200         ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
21201         if test "x$ISLINK" == x; then
21202           # This is not a symbolic link! We are done!
21203           break
21204         fi
21205         # Again resolve directory symlinks since the target of the just found
21206         # link could be in a different directory
21207         cd `$DIRNAME $ISLINK`
21208         sym_link_dir=`$THEPWDCMD -P`
21209         sym_link_file=`$BASENAME $ISLINK`
21210         let COUNTER=COUNTER+1
21211       done
21212       cd $STARTDIR
21213       BINARY=$sym_link_dir/$sym_link_file
21214     fi
21215   fi
21216 
21217     BOOT_JDK=`dirname "$BINARY"`
21218     BOOT_JDK=`cd "$BOOT_JDK/.."; pwd`
21219     if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then
21220       # Looks like we found ourselves an JDK
21221       BOOT_JDK_FOUND=maybe
21222       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using java(c) in PATH" >&5
21223 $as_echo "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
21224     fi
21225   fi
21226 
21227 
21228     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21229     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21230       # Do we have a bin/java?
21231       if test ! -x "$BOOT_JDK/bin/java"; then
21232         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21233 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21234         BOOT_JDK_FOUND=no
21235       else
21236         # Do we have a bin/javac?
21237         if test ! -x "$BOOT_JDK/bin/javac"; then
21238           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21239 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21240           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21241 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21242           BOOT_JDK_FOUND=no
21243         else
21244           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
21245           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
21246             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
21247 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
21248             BOOT_JDK_FOUND=no
21249           else
21250             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21251             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21252 
21253             # Extra M4 quote needed to protect [] in grep expression.
21254             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
21255             if test "x$FOUND_VERSION_78" = x; then
21256               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21257 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21258               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
21259 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
21260               BOOT_JDK_FOUND=no
21261             else
21262               # We're done! :-)
21263               BOOT_JDK_FOUND=yes
21264 
21265   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21266 
21267   # Input might be given as Windows format, start by converting to
21268   # unix format.
21269   path="$BOOT_JDK"
21270   new_path=`$CYGPATH -u "$path"`
21271 
21272   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21273   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21274   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21275   # "foo.exe" is OK but "foo" is an error.
21276   #
21277   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21278   # It is also a way to make sure we got the proper file name for the real test later on.
21279   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21280   if test "x$test_shortpath" = x; then
21281     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21282 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21283     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21284   fi
21285 
21286   # Call helper function which possibly converts this using DOS-style short mode.
21287   # If so, the updated path is stored in $new_path.
21288 
21289   input_path="$new_path"
21290   # Check if we need to convert this using DOS-style short mode. If the path
21291   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21292   # take no chances and rewrite it.
21293   # Note: m4 eats our [], so we need to use [ and ] instead.
21294   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21295   if test "x$has_forbidden_chars" != x; then
21296     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21297     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21298     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21299     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21300       # Going to short mode and back again did indeed matter. Since short mode is
21301       # case insensitive, let's make it lowercase to improve readability.
21302       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21303       # Now convert it back to Unix-style (cygpath)
21304       input_path=`$CYGPATH -u "$shortmode_path"`
21305       new_path="$input_path"
21306     fi
21307   fi
21308 
21309   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21310   if test "x$test_cygdrive_prefix" = x; then
21311     # As a simple fix, exclude /usr/bin since it's not a real path.
21312     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21313       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21314       # a path prefixed by /cygdrive for fixpath to work.
21315       new_path="$CYGWIN_ROOT_PATH$input_path"
21316     fi
21317   fi
21318 
21319 
21320   if test "x$path" != "x$new_path"; then
21321     BOOT_JDK="$new_path"
21322     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21323 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21324   fi
21325 
21326   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21327 
21328   path="$BOOT_JDK"
21329   has_colon=`$ECHO $path | $GREP ^.:`
21330   new_path="$path"
21331   if test "x$has_colon" = x; then
21332     # Not in mixed or Windows style, start by that.
21333     new_path=`cmd //c echo $path`
21334   fi
21335 
21336 
21337   input_path="$new_path"
21338   # Check if we need to convert this using DOS-style short mode. If the path
21339   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21340   # take no chances and rewrite it.
21341   # Note: m4 eats our [], so we need to use [ and ] instead.
21342   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21343   if test "x$has_forbidden_chars" != x; then
21344     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21345     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21346   fi
21347 
21348 
21349   windows_path="$new_path"
21350   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21351     unix_path=`$CYGPATH -u "$windows_path"`
21352     new_path="$unix_path"
21353   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21354     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21355     new_path="$unix_path"
21356   fi
21357 
21358   if test "x$path" != "x$new_path"; then
21359     BOOT_JDK="$new_path"
21360     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21361 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21362   fi
21363 
21364   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21365   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21366 
21367   else
21368     # We're on a posix platform. Hooray! :)
21369     path="$BOOT_JDK"
21370     has_space=`$ECHO "$path" | $GREP " "`
21371     if test "x$has_space" != x; then
21372       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21373 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21374       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21375     fi
21376 
21377     # Use eval to expand a potential ~
21378     eval path="$path"
21379     if test ! -f "$path" && test ! -d "$path"; then
21380       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21381     fi
21382 
21383     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21384   fi
21385 
21386               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21387 $as_echo_n "checking for Boot JDK... " >&6; }
21388               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21389 $as_echo "$BOOT_JDK" >&6; }
21390               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21391 $as_echo_n "checking Boot JDK version... " >&6; }
21392               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21393               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21394 $as_echo "$BOOT_JDK_VERSION" >&6; }
21395             fi # end check jdk version
21396           fi # end check rt.jar
21397         fi # end check javac
21398       fi # end check java
21399     fi # end check boot jdk found
21400   fi
21401 
21402 
21403   # Test: Is there a JDK installed in default, well-known locations?
21404 
21405   if test "x$BOOT_JDK_FOUND" = xno; then
21406     # Now execute the test
21407 
21408   if test "x$OPENJDK_TARGET_OS" = xwindows; then
21409 
21410   if test "x$BOOT_JDK_FOUND" = xno; then
21411     # Now execute the test
21412 
21413   if test "x$ProgramW6432" != x; then
21414     VIRTUAL_DIR="$ProgramW6432/Java"
21415 
21416   windows_path="$VIRTUAL_DIR"
21417   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21418     unix_path=`$CYGPATH -u "$windows_path"`
21419     VIRTUAL_DIR="$unix_path"
21420   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21421     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21422     VIRTUAL_DIR="$unix_path"
21423   fi
21424 
21425 
21426   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
21427   BOOT_JDK_SUFFIX=""
21428   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
21429   if test "x$ALL_JDKS_FOUND" != x; then
21430     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
21431 
21432   if test "x$BOOT_JDK_FOUND" = xno; then
21433     # Now execute the test
21434 
21435         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
21436         if test -d "$BOOT_JDK"; then
21437           BOOT_JDK_FOUND=maybe
21438           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
21439 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
21440         fi
21441 
21442 
21443     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21444     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21445       # Do we have a bin/java?
21446       if test ! -x "$BOOT_JDK/bin/java"; then
21447         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21448 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21449         BOOT_JDK_FOUND=no
21450       else
21451         # Do we have a bin/javac?
21452         if test ! -x "$BOOT_JDK/bin/javac"; then
21453           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21454 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21455           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21456 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21457           BOOT_JDK_FOUND=no
21458         else
21459           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
21460           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
21461             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
21462 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
21463             BOOT_JDK_FOUND=no
21464           else
21465             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21466             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21467 
21468             # Extra M4 quote needed to protect [] in grep expression.
21469             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
21470             if test "x$FOUND_VERSION_78" = x; then
21471               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21472 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21473               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
21474 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
21475               BOOT_JDK_FOUND=no
21476             else
21477               # We're done! :-)
21478               BOOT_JDK_FOUND=yes
21479 
21480   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21481 
21482   # Input might be given as Windows format, start by converting to
21483   # unix format.
21484   path="$BOOT_JDK"
21485   new_path=`$CYGPATH -u "$path"`
21486 
21487   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21488   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21489   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21490   # "foo.exe" is OK but "foo" is an error.
21491   #
21492   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21493   # It is also a way to make sure we got the proper file name for the real test later on.
21494   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21495   if test "x$test_shortpath" = x; then
21496     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21497 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21498     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21499   fi
21500 
21501   # Call helper function which possibly converts this using DOS-style short mode.
21502   # If so, the updated path is stored in $new_path.
21503 
21504   input_path="$new_path"
21505   # Check if we need to convert this using DOS-style short mode. If the path
21506   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21507   # take no chances and rewrite it.
21508   # Note: m4 eats our [], so we need to use [ and ] instead.
21509   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21510   if test "x$has_forbidden_chars" != x; then
21511     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21512     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21513     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21514     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21515       # Going to short mode and back again did indeed matter. Since short mode is
21516       # case insensitive, let's make it lowercase to improve readability.
21517       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21518       # Now convert it back to Unix-style (cygpath)
21519       input_path=`$CYGPATH -u "$shortmode_path"`
21520       new_path="$input_path"
21521     fi
21522   fi
21523 
21524   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21525   if test "x$test_cygdrive_prefix" = x; then
21526     # As a simple fix, exclude /usr/bin since it's not a real path.
21527     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21528       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21529       # a path prefixed by /cygdrive for fixpath to work.
21530       new_path="$CYGWIN_ROOT_PATH$input_path"
21531     fi
21532   fi
21533 
21534 
21535   if test "x$path" != "x$new_path"; then
21536     BOOT_JDK="$new_path"
21537     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21538 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21539   fi
21540 
21541   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21542 
21543   path="$BOOT_JDK"
21544   has_colon=`$ECHO $path | $GREP ^.:`
21545   new_path="$path"
21546   if test "x$has_colon" = x; then
21547     # Not in mixed or Windows style, start by that.
21548     new_path=`cmd //c echo $path`
21549   fi
21550 
21551 
21552   input_path="$new_path"
21553   # Check if we need to convert this using DOS-style short mode. If the path
21554   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21555   # take no chances and rewrite it.
21556   # Note: m4 eats our [], so we need to use [ and ] instead.
21557   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21558   if test "x$has_forbidden_chars" != x; then
21559     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21560     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21561   fi
21562 
21563 
21564   windows_path="$new_path"
21565   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21566     unix_path=`$CYGPATH -u "$windows_path"`
21567     new_path="$unix_path"
21568   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21569     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21570     new_path="$unix_path"
21571   fi
21572 
21573   if test "x$path" != "x$new_path"; then
21574     BOOT_JDK="$new_path"
21575     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21576 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21577   fi
21578 
21579   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21580   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21581 
21582   else
21583     # We're on a posix platform. Hooray! :)
21584     path="$BOOT_JDK"
21585     has_space=`$ECHO "$path" | $GREP " "`
21586     if test "x$has_space" != x; then
21587       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21588 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21589       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21590     fi
21591 
21592     # Use eval to expand a potential ~
21593     eval path="$path"
21594     if test ! -f "$path" && test ! -d "$path"; then
21595       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21596     fi
21597 
21598     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21599   fi
21600 
21601               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21602 $as_echo_n "checking for Boot JDK... " >&6; }
21603               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21604 $as_echo "$BOOT_JDK" >&6; }
21605               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21606 $as_echo_n "checking Boot JDK version... " >&6; }
21607               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21608               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21609 $as_echo "$BOOT_JDK_VERSION" >&6; }
21610             fi # end check jdk version
21611           fi # end check rt.jar
21612         fi # end check javac
21613       fi # end check java
21614     fi # end check boot jdk found
21615   fi
21616 
21617     done
21618   fi
21619 
21620   fi
21621 
21622 
21623     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21624     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21625       # Do we have a bin/java?
21626       if test ! -x "$BOOT_JDK/bin/java"; then
21627         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21628 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21629         BOOT_JDK_FOUND=no
21630       else
21631         # Do we have a bin/javac?
21632         if test ! -x "$BOOT_JDK/bin/javac"; then
21633           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21634 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21635           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21636 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21637           BOOT_JDK_FOUND=no
21638         else
21639           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
21640           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
21641             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
21642 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
21643             BOOT_JDK_FOUND=no
21644           else
21645             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21646             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21647 
21648             # Extra M4 quote needed to protect [] in grep expression.
21649             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
21650             if test "x$FOUND_VERSION_78" = x; then
21651               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21652 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21653               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
21654 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
21655               BOOT_JDK_FOUND=no
21656             else
21657               # We're done! :-)
21658               BOOT_JDK_FOUND=yes
21659 
21660   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21661 
21662   # Input might be given as Windows format, start by converting to
21663   # unix format.
21664   path="$BOOT_JDK"
21665   new_path=`$CYGPATH -u "$path"`
21666 
21667   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21668   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21669   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21670   # "foo.exe" is OK but "foo" is an error.
21671   #
21672   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21673   # It is also a way to make sure we got the proper file name for the real test later on.
21674   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21675   if test "x$test_shortpath" = x; then
21676     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21677 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21678     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21679   fi
21680 
21681   # Call helper function which possibly converts this using DOS-style short mode.
21682   # If so, the updated path is stored in $new_path.
21683 
21684   input_path="$new_path"
21685   # Check if we need to convert this using DOS-style short mode. If the path
21686   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21687   # take no chances and rewrite it.
21688   # Note: m4 eats our [], so we need to use [ and ] instead.
21689   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21690   if test "x$has_forbidden_chars" != x; then
21691     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21692     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21693     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21694     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21695       # Going to short mode and back again did indeed matter. Since short mode is
21696       # case insensitive, let's make it lowercase to improve readability.
21697       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21698       # Now convert it back to Unix-style (cygpath)
21699       input_path=`$CYGPATH -u "$shortmode_path"`
21700       new_path="$input_path"
21701     fi
21702   fi
21703 
21704   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21705   if test "x$test_cygdrive_prefix" = x; then
21706     # As a simple fix, exclude /usr/bin since it's not a real path.
21707     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21708       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21709       # a path prefixed by /cygdrive for fixpath to work.
21710       new_path="$CYGWIN_ROOT_PATH$input_path"
21711     fi
21712   fi
21713 
21714 
21715   if test "x$path" != "x$new_path"; then
21716     BOOT_JDK="$new_path"
21717     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21718 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21719   fi
21720 
21721   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21722 
21723   path="$BOOT_JDK"
21724   has_colon=`$ECHO $path | $GREP ^.:`
21725   new_path="$path"
21726   if test "x$has_colon" = x; then
21727     # Not in mixed or Windows style, start by that.
21728     new_path=`cmd //c echo $path`
21729   fi
21730 
21731 
21732   input_path="$new_path"
21733   # Check if we need to convert this using DOS-style short mode. If the path
21734   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21735   # take no chances and rewrite it.
21736   # Note: m4 eats our [], so we need to use [ and ] instead.
21737   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21738   if test "x$has_forbidden_chars" != x; then
21739     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21740     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21741   fi
21742 
21743 
21744   windows_path="$new_path"
21745   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21746     unix_path=`$CYGPATH -u "$windows_path"`
21747     new_path="$unix_path"
21748   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21749     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21750     new_path="$unix_path"
21751   fi
21752 
21753   if test "x$path" != "x$new_path"; then
21754     BOOT_JDK="$new_path"
21755     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21756 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21757   fi
21758 
21759   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21760   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21761 
21762   else
21763     # We're on a posix platform. Hooray! :)
21764     path="$BOOT_JDK"
21765     has_space=`$ECHO "$path" | $GREP " "`
21766     if test "x$has_space" != x; then
21767       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21768 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21769       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21770     fi
21771 
21772     # Use eval to expand a potential ~
21773     eval path="$path"
21774     if test ! -f "$path" && test ! -d "$path"; then
21775       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21776     fi
21777 
21778     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21779   fi
21780 
21781               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21782 $as_echo_n "checking for Boot JDK... " >&6; }
21783               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21784 $as_echo "$BOOT_JDK" >&6; }
21785               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21786 $as_echo_n "checking Boot JDK version... " >&6; }
21787               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21788               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21789 $as_echo "$BOOT_JDK_VERSION" >&6; }
21790             fi # end check jdk version
21791           fi # end check rt.jar
21792         fi # end check javac
21793       fi # end check java
21794     fi # end check boot jdk found
21795   fi
21796 
21797 
21798   if test "x$BOOT_JDK_FOUND" = xno; then
21799     # Now execute the test
21800 
21801   if test "x$PROGRAMW6432" != x; then
21802     VIRTUAL_DIR="$PROGRAMW6432/Java"
21803 
21804   windows_path="$VIRTUAL_DIR"
21805   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21806     unix_path=`$CYGPATH -u "$windows_path"`
21807     VIRTUAL_DIR="$unix_path"
21808   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21809     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21810     VIRTUAL_DIR="$unix_path"
21811   fi
21812 
21813 
21814   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
21815   BOOT_JDK_SUFFIX=""
21816   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
21817   if test "x$ALL_JDKS_FOUND" != x; then
21818     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
21819 
21820   if test "x$BOOT_JDK_FOUND" = xno; then
21821     # Now execute the test
21822 
21823         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
21824         if test -d "$BOOT_JDK"; then
21825           BOOT_JDK_FOUND=maybe
21826           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
21827 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
21828         fi
21829 
21830 
21831     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21832     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21833       # Do we have a bin/java?
21834       if test ! -x "$BOOT_JDK/bin/java"; then
21835         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21836 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21837         BOOT_JDK_FOUND=no
21838       else
21839         # Do we have a bin/javac?
21840         if test ! -x "$BOOT_JDK/bin/javac"; then
21841           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21842 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21843           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21844 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21845           BOOT_JDK_FOUND=no
21846         else
21847           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
21848           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
21849             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
21850 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
21851             BOOT_JDK_FOUND=no
21852           else
21853             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21854             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21855 
21856             # Extra M4 quote needed to protect [] in grep expression.
21857             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
21858             if test "x$FOUND_VERSION_78" = x; then
21859               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21860 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21861               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
21862 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
21863               BOOT_JDK_FOUND=no
21864             else
21865               # We're done! :-)
21866               BOOT_JDK_FOUND=yes
21867 
21868   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21869 
21870   # Input might be given as Windows format, start by converting to
21871   # unix format.
21872   path="$BOOT_JDK"
21873   new_path=`$CYGPATH -u "$path"`
21874 
21875   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21876   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21877   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21878   # "foo.exe" is OK but "foo" is an error.
21879   #
21880   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21881   # It is also a way to make sure we got the proper file name for the real test later on.
21882   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21883   if test "x$test_shortpath" = x; then
21884     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21885 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21886     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21887   fi
21888 
21889   # Call helper function which possibly converts this using DOS-style short mode.
21890   # If so, the updated path is stored in $new_path.
21891 
21892   input_path="$new_path"
21893   # Check if we need to convert this using DOS-style short mode. If the path
21894   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21895   # take no chances and rewrite it.
21896   # Note: m4 eats our [], so we need to use [ and ] instead.
21897   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21898   if test "x$has_forbidden_chars" != x; then
21899     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21900     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21901     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21902     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21903       # Going to short mode and back again did indeed matter. Since short mode is
21904       # case insensitive, let's make it lowercase to improve readability.
21905       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21906       # Now convert it back to Unix-style (cygpath)
21907       input_path=`$CYGPATH -u "$shortmode_path"`
21908       new_path="$input_path"
21909     fi
21910   fi
21911 
21912   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21913   if test "x$test_cygdrive_prefix" = x; then
21914     # As a simple fix, exclude /usr/bin since it's not a real path.
21915     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21916       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21917       # a path prefixed by /cygdrive for fixpath to work.
21918       new_path="$CYGWIN_ROOT_PATH$input_path"
21919     fi
21920   fi
21921 
21922 
21923   if test "x$path" != "x$new_path"; then
21924     BOOT_JDK="$new_path"
21925     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21926 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21927   fi
21928 
21929   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21930 
21931   path="$BOOT_JDK"
21932   has_colon=`$ECHO $path | $GREP ^.:`
21933   new_path="$path"
21934   if test "x$has_colon" = x; then
21935     # Not in mixed or Windows style, start by that.
21936     new_path=`cmd //c echo $path`
21937   fi
21938 
21939 
21940   input_path="$new_path"
21941   # Check if we need to convert this using DOS-style short mode. If the path
21942   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21943   # take no chances and rewrite it.
21944   # Note: m4 eats our [], so we need to use [ and ] instead.
21945   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21946   if test "x$has_forbidden_chars" != x; then
21947     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21948     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21949   fi
21950 
21951 
21952   windows_path="$new_path"
21953   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21954     unix_path=`$CYGPATH -u "$windows_path"`
21955     new_path="$unix_path"
21956   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21957     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21958     new_path="$unix_path"
21959   fi
21960 
21961   if test "x$path" != "x$new_path"; then
21962     BOOT_JDK="$new_path"
21963     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21964 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21965   fi
21966 
21967   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21968   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21969 
21970   else
21971     # We're on a posix platform. Hooray! :)
21972     path="$BOOT_JDK"
21973     has_space=`$ECHO "$path" | $GREP " "`
21974     if test "x$has_space" != x; then
21975       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21976 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21977       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21978     fi
21979 
21980     # Use eval to expand a potential ~
21981     eval path="$path"
21982     if test ! -f "$path" && test ! -d "$path"; then
21983       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21984     fi
21985 
21986     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21987   fi
21988 
21989               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21990 $as_echo_n "checking for Boot JDK... " >&6; }
21991               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21992 $as_echo "$BOOT_JDK" >&6; }
21993               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21994 $as_echo_n "checking Boot JDK version... " >&6; }
21995               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21996               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21997 $as_echo "$BOOT_JDK_VERSION" >&6; }
21998             fi # end check jdk version
21999           fi # end check rt.jar
22000         fi # end check javac
22001       fi # end check java
22002     fi # end check boot jdk found
22003   fi
22004 
22005     done
22006   fi
22007 
22008   fi
22009 
22010 
22011     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22012     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22013       # Do we have a bin/java?
22014       if test ! -x "$BOOT_JDK/bin/java"; then
22015         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22016 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22017         BOOT_JDK_FOUND=no
22018       else
22019         # Do we have a bin/javac?
22020         if test ! -x "$BOOT_JDK/bin/javac"; then
22021           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22022 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22023           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22024 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22025           BOOT_JDK_FOUND=no
22026         else
22027           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22028           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22029             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22030 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22031             BOOT_JDK_FOUND=no
22032           else
22033             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22034             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22035 
22036             # Extra M4 quote needed to protect [] in grep expression.
22037             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
22038             if test "x$FOUND_VERSION_78" = x; then
22039               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22040 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22041               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
22042 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
22043               BOOT_JDK_FOUND=no
22044             else
22045               # We're done! :-)
22046               BOOT_JDK_FOUND=yes
22047 
22048   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22049 
22050   # Input might be given as Windows format, start by converting to
22051   # unix format.
22052   path="$BOOT_JDK"
22053   new_path=`$CYGPATH -u "$path"`
22054 
22055   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22056   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22057   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22058   # "foo.exe" is OK but "foo" is an error.
22059   #
22060   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22061   # It is also a way to make sure we got the proper file name for the real test later on.
22062   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22063   if test "x$test_shortpath" = x; then
22064     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22065 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22066     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22067   fi
22068 
22069   # Call helper function which possibly converts this using DOS-style short mode.
22070   # If so, the updated path is stored in $new_path.
22071 
22072   input_path="$new_path"
22073   # Check if we need to convert this using DOS-style short mode. If the path
22074   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22075   # take no chances and rewrite it.
22076   # Note: m4 eats our [], so we need to use [ and ] instead.
22077   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22078   if test "x$has_forbidden_chars" != x; then
22079     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22080     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22081     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22082     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22083       # Going to short mode and back again did indeed matter. Since short mode is
22084       # case insensitive, let's make it lowercase to improve readability.
22085       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22086       # Now convert it back to Unix-style (cygpath)
22087       input_path=`$CYGPATH -u "$shortmode_path"`
22088       new_path="$input_path"
22089     fi
22090   fi
22091 
22092   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22093   if test "x$test_cygdrive_prefix" = x; then
22094     # As a simple fix, exclude /usr/bin since it's not a real path.
22095     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22096       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22097       # a path prefixed by /cygdrive for fixpath to work.
22098       new_path="$CYGWIN_ROOT_PATH$input_path"
22099     fi
22100   fi
22101 
22102 
22103   if test "x$path" != "x$new_path"; then
22104     BOOT_JDK="$new_path"
22105     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22106 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22107   fi
22108 
22109   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22110 
22111   path="$BOOT_JDK"
22112   has_colon=`$ECHO $path | $GREP ^.:`
22113   new_path="$path"
22114   if test "x$has_colon" = x; then
22115     # Not in mixed or Windows style, start by that.
22116     new_path=`cmd //c echo $path`
22117   fi
22118 
22119 
22120   input_path="$new_path"
22121   # Check if we need to convert this using DOS-style short mode. If the path
22122   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22123   # take no chances and rewrite it.
22124   # Note: m4 eats our [], so we need to use [ and ] instead.
22125   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22126   if test "x$has_forbidden_chars" != x; then
22127     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22128     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22129   fi
22130 
22131 
22132   windows_path="$new_path"
22133   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22134     unix_path=`$CYGPATH -u "$windows_path"`
22135     new_path="$unix_path"
22136   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22137     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22138     new_path="$unix_path"
22139   fi
22140 
22141   if test "x$path" != "x$new_path"; then
22142     BOOT_JDK="$new_path"
22143     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22144 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22145   fi
22146 
22147   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22148   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22149 
22150   else
22151     # We're on a posix platform. Hooray! :)
22152     path="$BOOT_JDK"
22153     has_space=`$ECHO "$path" | $GREP " "`
22154     if test "x$has_space" != x; then
22155       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22156 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22157       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22158     fi
22159 
22160     # Use eval to expand a potential ~
22161     eval path="$path"
22162     if test ! -f "$path" && test ! -d "$path"; then
22163       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22164     fi
22165 
22166     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22167   fi
22168 
22169               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22170 $as_echo_n "checking for Boot JDK... " >&6; }
22171               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22172 $as_echo "$BOOT_JDK" >&6; }
22173               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22174 $as_echo_n "checking Boot JDK version... " >&6; }
22175               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22176               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22177 $as_echo "$BOOT_JDK_VERSION" >&6; }
22178             fi # end check jdk version
22179           fi # end check rt.jar
22180         fi # end check javac
22181       fi # end check java
22182     fi # end check boot jdk found
22183   fi
22184 
22185 
22186   if test "x$BOOT_JDK_FOUND" = xno; then
22187     # Now execute the test
22188 
22189   if test "x$PROGRAMFILES" != x; then
22190     VIRTUAL_DIR="$PROGRAMFILES/Java"
22191 
22192   windows_path="$VIRTUAL_DIR"
22193   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22194     unix_path=`$CYGPATH -u "$windows_path"`
22195     VIRTUAL_DIR="$unix_path"
22196   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22197     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22198     VIRTUAL_DIR="$unix_path"
22199   fi
22200 
22201 
22202   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22203   BOOT_JDK_SUFFIX=""
22204   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22205   if test "x$ALL_JDKS_FOUND" != x; then
22206     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22207 
22208   if test "x$BOOT_JDK_FOUND" = xno; then
22209     # Now execute the test
22210 
22211         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22212         if test -d "$BOOT_JDK"; then
22213           BOOT_JDK_FOUND=maybe
22214           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22215 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22216         fi
22217 
22218 
22219     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22220     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22221       # Do we have a bin/java?
22222       if test ! -x "$BOOT_JDK/bin/java"; then
22223         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22224 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22225         BOOT_JDK_FOUND=no
22226       else
22227         # Do we have a bin/javac?
22228         if test ! -x "$BOOT_JDK/bin/javac"; then
22229           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22230 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22231           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22232 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22233           BOOT_JDK_FOUND=no
22234         else
22235           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22236           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22237             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22238 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22239             BOOT_JDK_FOUND=no
22240           else
22241             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22242             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22243 
22244             # Extra M4 quote needed to protect [] in grep expression.
22245             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
22246             if test "x$FOUND_VERSION_78" = x; then
22247               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22248 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22249               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
22250 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
22251               BOOT_JDK_FOUND=no
22252             else
22253               # We're done! :-)
22254               BOOT_JDK_FOUND=yes
22255 
22256   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22257 
22258   # Input might be given as Windows format, start by converting to
22259   # unix format.
22260   path="$BOOT_JDK"
22261   new_path=`$CYGPATH -u "$path"`
22262 
22263   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22264   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22265   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22266   # "foo.exe" is OK but "foo" is an error.
22267   #
22268   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22269   # It is also a way to make sure we got the proper file name for the real test later on.
22270   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22271   if test "x$test_shortpath" = x; then
22272     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22273 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22274     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22275   fi
22276 
22277   # Call helper function which possibly converts this using DOS-style short mode.
22278   # If so, the updated path is stored in $new_path.
22279 
22280   input_path="$new_path"
22281   # Check if we need to convert this using DOS-style short mode. If the path
22282   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22283   # take no chances and rewrite it.
22284   # Note: m4 eats our [], so we need to use [ and ] instead.
22285   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22286   if test "x$has_forbidden_chars" != x; then
22287     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22288     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22289     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22290     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22291       # Going to short mode and back again did indeed matter. Since short mode is
22292       # case insensitive, let's make it lowercase to improve readability.
22293       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22294       # Now convert it back to Unix-style (cygpath)
22295       input_path=`$CYGPATH -u "$shortmode_path"`
22296       new_path="$input_path"
22297     fi
22298   fi
22299 
22300   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22301   if test "x$test_cygdrive_prefix" = x; then
22302     # As a simple fix, exclude /usr/bin since it's not a real path.
22303     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22304       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22305       # a path prefixed by /cygdrive for fixpath to work.
22306       new_path="$CYGWIN_ROOT_PATH$input_path"
22307     fi
22308   fi
22309 
22310 
22311   if test "x$path" != "x$new_path"; then
22312     BOOT_JDK="$new_path"
22313     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22314 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22315   fi
22316 
22317   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22318 
22319   path="$BOOT_JDK"
22320   has_colon=`$ECHO $path | $GREP ^.:`
22321   new_path="$path"
22322   if test "x$has_colon" = x; then
22323     # Not in mixed or Windows style, start by that.
22324     new_path=`cmd //c echo $path`
22325   fi
22326 
22327 
22328   input_path="$new_path"
22329   # Check if we need to convert this using DOS-style short mode. If the path
22330   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22331   # take no chances and rewrite it.
22332   # Note: m4 eats our [], so we need to use [ and ] instead.
22333   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22334   if test "x$has_forbidden_chars" != x; then
22335     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22336     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22337   fi
22338 
22339 
22340   windows_path="$new_path"
22341   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22342     unix_path=`$CYGPATH -u "$windows_path"`
22343     new_path="$unix_path"
22344   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22345     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22346     new_path="$unix_path"
22347   fi
22348 
22349   if test "x$path" != "x$new_path"; then
22350     BOOT_JDK="$new_path"
22351     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22352 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22353   fi
22354 
22355   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22356   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22357 
22358   else
22359     # We're on a posix platform. Hooray! :)
22360     path="$BOOT_JDK"
22361     has_space=`$ECHO "$path" | $GREP " "`
22362     if test "x$has_space" != x; then
22363       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22364 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22365       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22366     fi
22367 
22368     # Use eval to expand a potential ~
22369     eval path="$path"
22370     if test ! -f "$path" && test ! -d "$path"; then
22371       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22372     fi
22373 
22374     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22375   fi
22376 
22377               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22378 $as_echo_n "checking for Boot JDK... " >&6; }
22379               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22380 $as_echo "$BOOT_JDK" >&6; }
22381               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22382 $as_echo_n "checking Boot JDK version... " >&6; }
22383               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22384               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22385 $as_echo "$BOOT_JDK_VERSION" >&6; }
22386             fi # end check jdk version
22387           fi # end check rt.jar
22388         fi # end check javac
22389       fi # end check java
22390     fi # end check boot jdk found
22391   fi
22392 
22393     done
22394   fi
22395 
22396   fi
22397 
22398 
22399     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22400     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22401       # Do we have a bin/java?
22402       if test ! -x "$BOOT_JDK/bin/java"; then
22403         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22404 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22405         BOOT_JDK_FOUND=no
22406       else
22407         # Do we have a bin/javac?
22408         if test ! -x "$BOOT_JDK/bin/javac"; then
22409           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22410 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22411           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22412 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22413           BOOT_JDK_FOUND=no
22414         else
22415           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22416           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22417             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22418 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22419             BOOT_JDK_FOUND=no
22420           else
22421             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22422             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22423 
22424             # Extra M4 quote needed to protect [] in grep expression.
22425             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
22426             if test "x$FOUND_VERSION_78" = x; then
22427               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22428 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22429               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
22430 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
22431               BOOT_JDK_FOUND=no
22432             else
22433               # We're done! :-)
22434               BOOT_JDK_FOUND=yes
22435 
22436   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22437 
22438   # Input might be given as Windows format, start by converting to
22439   # unix format.
22440   path="$BOOT_JDK"
22441   new_path=`$CYGPATH -u "$path"`
22442 
22443   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22444   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22445   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22446   # "foo.exe" is OK but "foo" is an error.
22447   #
22448   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22449   # It is also a way to make sure we got the proper file name for the real test later on.
22450   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22451   if test "x$test_shortpath" = x; then
22452     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22453 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22454     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22455   fi
22456 
22457   # Call helper function which possibly converts this using DOS-style short mode.
22458   # If so, the updated path is stored in $new_path.
22459 
22460   input_path="$new_path"
22461   # Check if we need to convert this using DOS-style short mode. If the path
22462   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22463   # take no chances and rewrite it.
22464   # Note: m4 eats our [], so we need to use [ and ] instead.
22465   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22466   if test "x$has_forbidden_chars" != x; then
22467     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22468     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22469     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22470     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22471       # Going to short mode and back again did indeed matter. Since short mode is
22472       # case insensitive, let's make it lowercase to improve readability.
22473       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22474       # Now convert it back to Unix-style (cygpath)
22475       input_path=`$CYGPATH -u "$shortmode_path"`
22476       new_path="$input_path"
22477     fi
22478   fi
22479 
22480   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22481   if test "x$test_cygdrive_prefix" = x; then
22482     # As a simple fix, exclude /usr/bin since it's not a real path.
22483     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22484       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22485       # a path prefixed by /cygdrive for fixpath to work.
22486       new_path="$CYGWIN_ROOT_PATH$input_path"
22487     fi
22488   fi
22489 
22490 
22491   if test "x$path" != "x$new_path"; then
22492     BOOT_JDK="$new_path"
22493     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22494 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22495   fi
22496 
22497   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22498 
22499   path="$BOOT_JDK"
22500   has_colon=`$ECHO $path | $GREP ^.:`
22501   new_path="$path"
22502   if test "x$has_colon" = x; then
22503     # Not in mixed or Windows style, start by that.
22504     new_path=`cmd //c echo $path`
22505   fi
22506 
22507 
22508   input_path="$new_path"
22509   # Check if we need to convert this using DOS-style short mode. If the path
22510   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22511   # take no chances and rewrite it.
22512   # Note: m4 eats our [], so we need to use [ and ] instead.
22513   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22514   if test "x$has_forbidden_chars" != x; then
22515     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22516     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22517   fi
22518 
22519 
22520   windows_path="$new_path"
22521   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22522     unix_path=`$CYGPATH -u "$windows_path"`
22523     new_path="$unix_path"
22524   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22525     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22526     new_path="$unix_path"
22527   fi
22528 
22529   if test "x$path" != "x$new_path"; then
22530     BOOT_JDK="$new_path"
22531     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22532 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22533   fi
22534 
22535   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22536   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22537 
22538   else
22539     # We're on a posix platform. Hooray! :)
22540     path="$BOOT_JDK"
22541     has_space=`$ECHO "$path" | $GREP " "`
22542     if test "x$has_space" != x; then
22543       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22544 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22545       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22546     fi
22547 
22548     # Use eval to expand a potential ~
22549     eval path="$path"
22550     if test ! -f "$path" && test ! -d "$path"; then
22551       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22552     fi
22553 
22554     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22555   fi
22556 
22557               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22558 $as_echo_n "checking for Boot JDK... " >&6; }
22559               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22560 $as_echo "$BOOT_JDK" >&6; }
22561               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22562 $as_echo_n "checking Boot JDK version... " >&6; }
22563               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22564               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22565 $as_echo "$BOOT_JDK_VERSION" >&6; }
22566             fi # end check jdk version
22567           fi # end check rt.jar
22568         fi # end check javac
22569       fi # end check java
22570     fi # end check boot jdk found
22571   fi
22572 
22573 
22574   if test "x$BOOT_JDK_FOUND" = xno; then
22575     # Now execute the test
22576 
22577   if test "x$ProgramFiles" != x; then
22578     VIRTUAL_DIR="$ProgramFiles/Java"
22579 
22580   windows_path="$VIRTUAL_DIR"
22581   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22582     unix_path=`$CYGPATH -u "$windows_path"`
22583     VIRTUAL_DIR="$unix_path"
22584   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22585     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22586     VIRTUAL_DIR="$unix_path"
22587   fi
22588 
22589 
22590   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22591   BOOT_JDK_SUFFIX=""
22592   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22593   if test "x$ALL_JDKS_FOUND" != x; then
22594     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22595 
22596   if test "x$BOOT_JDK_FOUND" = xno; then
22597     # Now execute the test
22598 
22599         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22600         if test -d "$BOOT_JDK"; then
22601           BOOT_JDK_FOUND=maybe
22602           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22603 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22604         fi
22605 
22606 
22607     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22608     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22609       # Do we have a bin/java?
22610       if test ! -x "$BOOT_JDK/bin/java"; then
22611         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22612 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22613         BOOT_JDK_FOUND=no
22614       else
22615         # Do we have a bin/javac?
22616         if test ! -x "$BOOT_JDK/bin/javac"; then
22617           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22618 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22619           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22620 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22621           BOOT_JDK_FOUND=no
22622         else
22623           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22624           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22625             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22626 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22627             BOOT_JDK_FOUND=no
22628           else
22629             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22630             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22631 
22632             # Extra M4 quote needed to protect [] in grep expression.
22633             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
22634             if test "x$FOUND_VERSION_78" = x; then
22635               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22636 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22637               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
22638 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
22639               BOOT_JDK_FOUND=no
22640             else
22641               # We're done! :-)
22642               BOOT_JDK_FOUND=yes
22643 
22644   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22645 
22646   # Input might be given as Windows format, start by converting to
22647   # unix format.
22648   path="$BOOT_JDK"
22649   new_path=`$CYGPATH -u "$path"`
22650 
22651   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22652   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22653   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22654   # "foo.exe" is OK but "foo" is an error.
22655   #
22656   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22657   # It is also a way to make sure we got the proper file name for the real test later on.
22658   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22659   if test "x$test_shortpath" = x; then
22660     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22661 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22662     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22663   fi
22664 
22665   # Call helper function which possibly converts this using DOS-style short mode.
22666   # If so, the updated path is stored in $new_path.
22667 
22668   input_path="$new_path"
22669   # Check if we need to convert this using DOS-style short mode. If the path
22670   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22671   # take no chances and rewrite it.
22672   # Note: m4 eats our [], so we need to use [ and ] instead.
22673   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22674   if test "x$has_forbidden_chars" != x; then
22675     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22676     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22677     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22678     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22679       # Going to short mode and back again did indeed matter. Since short mode is
22680       # case insensitive, let's make it lowercase to improve readability.
22681       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22682       # Now convert it back to Unix-style (cygpath)
22683       input_path=`$CYGPATH -u "$shortmode_path"`
22684       new_path="$input_path"
22685     fi
22686   fi
22687 
22688   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22689   if test "x$test_cygdrive_prefix" = x; then
22690     # As a simple fix, exclude /usr/bin since it's not a real path.
22691     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22692       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22693       # a path prefixed by /cygdrive for fixpath to work.
22694       new_path="$CYGWIN_ROOT_PATH$input_path"
22695     fi
22696   fi
22697 
22698 
22699   if test "x$path" != "x$new_path"; then
22700     BOOT_JDK="$new_path"
22701     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22702 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22703   fi
22704 
22705   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22706 
22707   path="$BOOT_JDK"
22708   has_colon=`$ECHO $path | $GREP ^.:`
22709   new_path="$path"
22710   if test "x$has_colon" = x; then
22711     # Not in mixed or Windows style, start by that.
22712     new_path=`cmd //c echo $path`
22713   fi
22714 
22715 
22716   input_path="$new_path"
22717   # Check if we need to convert this using DOS-style short mode. If the path
22718   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22719   # take no chances and rewrite it.
22720   # Note: m4 eats our [], so we need to use [ and ] instead.
22721   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22722   if test "x$has_forbidden_chars" != x; then
22723     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22724     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22725   fi
22726 
22727 
22728   windows_path="$new_path"
22729   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22730     unix_path=`$CYGPATH -u "$windows_path"`
22731     new_path="$unix_path"
22732   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22733     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22734     new_path="$unix_path"
22735   fi
22736 
22737   if test "x$path" != "x$new_path"; then
22738     BOOT_JDK="$new_path"
22739     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22740 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22741   fi
22742 
22743   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22744   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22745 
22746   else
22747     # We're on a posix platform. Hooray! :)
22748     path="$BOOT_JDK"
22749     has_space=`$ECHO "$path" | $GREP " "`
22750     if test "x$has_space" != x; then
22751       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22752 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22753       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22754     fi
22755 
22756     # Use eval to expand a potential ~
22757     eval path="$path"
22758     if test ! -f "$path" && test ! -d "$path"; then
22759       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22760     fi
22761 
22762     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22763   fi
22764 
22765               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22766 $as_echo_n "checking for Boot JDK... " >&6; }
22767               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22768 $as_echo "$BOOT_JDK" >&6; }
22769               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22770 $as_echo_n "checking Boot JDK version... " >&6; }
22771               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22772               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22773 $as_echo "$BOOT_JDK_VERSION" >&6; }
22774             fi # end check jdk version
22775           fi # end check rt.jar
22776         fi # end check javac
22777       fi # end check java
22778     fi # end check boot jdk found
22779   fi
22780 
22781     done
22782   fi
22783 
22784   fi
22785 
22786 
22787     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22788     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22789       # Do we have a bin/java?
22790       if test ! -x "$BOOT_JDK/bin/java"; then
22791         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22792 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22793         BOOT_JDK_FOUND=no
22794       else
22795         # Do we have a bin/javac?
22796         if test ! -x "$BOOT_JDK/bin/javac"; then
22797           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22798 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22799           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22800 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22801           BOOT_JDK_FOUND=no
22802         else
22803           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22804           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
22805             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
22806 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
22807             BOOT_JDK_FOUND=no
22808           else
22809             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22810             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22811 
22812             # Extra M4 quote needed to protect [] in grep expression.
22813             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
22814             if test "x$FOUND_VERSION_78" = x; then
22815               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22816 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22817               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
22818 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
22819               BOOT_JDK_FOUND=no
22820             else
22821               # We're done! :-)
22822               BOOT_JDK_FOUND=yes
22823 
22824   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22825 
22826   # Input might be given as Windows format, start by converting to
22827   # unix format.
22828   path="$BOOT_JDK"
22829   new_path=`$CYGPATH -u "$path"`
22830 
22831   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22832   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22833   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22834   # "foo.exe" is OK but "foo" is an error.
22835   #
22836   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22837   # It is also a way to make sure we got the proper file name for the real test later on.
22838   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22839   if test "x$test_shortpath" = x; then
22840     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22841 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22842     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22843   fi
22844 
22845   # Call helper function which possibly converts this using DOS-style short mode.
22846   # If so, the updated path is stored in $new_path.
22847 
22848   input_path="$new_path"
22849   # Check if we need to convert this using DOS-style short mode. If the path
22850   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22851   # take no chances and rewrite it.
22852   # Note: m4 eats our [], so we need to use [ and ] instead.
22853   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22854   if test "x$has_forbidden_chars" != x; then
22855     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22856     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22857     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22858     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22859       # Going to short mode and back again did indeed matter. Since short mode is
22860       # case insensitive, let's make it lowercase to improve readability.
22861       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22862       # Now convert it back to Unix-style (cygpath)
22863       input_path=`$CYGPATH -u "$shortmode_path"`
22864       new_path="$input_path"
22865     fi
22866   fi
22867 
22868   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22869   if test "x$test_cygdrive_prefix" = x; then
22870     # As a simple fix, exclude /usr/bin since it's not a real path.
22871     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22872       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22873       # a path prefixed by /cygdrive for fixpath to work.
22874       new_path="$CYGWIN_ROOT_PATH$input_path"
22875     fi
22876   fi
22877 
22878 
22879   if test "x$path" != "x$new_path"; then
22880     BOOT_JDK="$new_path"
22881     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22882 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22883   fi
22884 
22885   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22886 
22887   path="$BOOT_JDK"
22888   has_colon=`$ECHO $path | $GREP ^.:`
22889   new_path="$path"
22890   if test "x$has_colon" = x; then
22891     # Not in mixed or Windows style, start by that.
22892     new_path=`cmd //c echo $path`
22893   fi
22894 
22895 
22896   input_path="$new_path"
22897   # Check if we need to convert this using DOS-style short mode. If the path
22898   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22899   # take no chances and rewrite it.
22900   # Note: m4 eats our [], so we need to use [ and ] instead.
22901   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22902   if test "x$has_forbidden_chars" != x; then
22903     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22904     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22905   fi
22906 
22907 
22908   windows_path="$new_path"
22909   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22910     unix_path=`$CYGPATH -u "$windows_path"`
22911     new_path="$unix_path"
22912   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22913     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22914     new_path="$unix_path"
22915   fi
22916 
22917   if test "x$path" != "x$new_path"; then
22918     BOOT_JDK="$new_path"
22919     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22920 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22921   fi
22922 
22923   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22924   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22925 
22926   else
22927     # We're on a posix platform. Hooray! :)
22928     path="$BOOT_JDK"
22929     has_space=`$ECHO "$path" | $GREP " "`
22930     if test "x$has_space" != x; then
22931       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22932 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22933       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22934     fi
22935 
22936     # Use eval to expand a potential ~
22937     eval path="$path"
22938     if test ! -f "$path" && test ! -d "$path"; then
22939       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22940     fi
22941 
22942     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22943   fi
22944 
22945               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22946 $as_echo_n "checking for Boot JDK... " >&6; }
22947               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22948 $as_echo "$BOOT_JDK" >&6; }
22949               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22950 $as_echo_n "checking Boot JDK version... " >&6; }
22951               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22952               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22953 $as_echo "$BOOT_JDK_VERSION" >&6; }
22954             fi # end check jdk version
22955           fi # end check rt.jar
22956         fi # end check javac
22957       fi # end check java
22958     fi # end check boot jdk found
22959   fi
22960 
22961 
22962   if test "x$BOOT_JDK_FOUND" = xno; then
22963     # Now execute the test
22964 
22965   BOOT_JDK_PREFIX="/cygdrive/c/Program Files/Java"
22966   BOOT_JDK_SUFFIX=""
22967   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22968   if test "x$ALL_JDKS_FOUND" != x; then
22969     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22970 
22971   if test "x$BOOT_JDK_FOUND" = xno; then
22972     # Now execute the test
22973 
22974         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22975         if test -d "$BOOT_JDK"; then
22976           BOOT_JDK_FOUND=maybe
22977           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22978 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22979         fi
22980 
22981 
22982     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22983     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22984       # Do we have a bin/java?
22985       if test ! -x "$BOOT_JDK/bin/java"; then
22986         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22987 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22988         BOOT_JDK_FOUND=no
22989       else
22990         # Do we have a bin/javac?
22991         if test ! -x "$BOOT_JDK/bin/javac"; then
22992           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22993 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22994           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22995 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22996           BOOT_JDK_FOUND=no
22997         else
22998           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
22999           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23000             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23001 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23002             BOOT_JDK_FOUND=no
23003           else
23004             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23005             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23006 
23007             # Extra M4 quote needed to protect [] in grep expression.
23008             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
23009             if test "x$FOUND_VERSION_78" = x; then
23010               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23011 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23012               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
23013 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
23014               BOOT_JDK_FOUND=no
23015             else
23016               # We're done! :-)
23017               BOOT_JDK_FOUND=yes
23018 
23019   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23020 
23021   # Input might be given as Windows format, start by converting to
23022   # unix format.
23023   path="$BOOT_JDK"
23024   new_path=`$CYGPATH -u "$path"`
23025 
23026   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23027   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23028   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23029   # "foo.exe" is OK but "foo" is an error.
23030   #
23031   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23032   # It is also a way to make sure we got the proper file name for the real test later on.
23033   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23034   if test "x$test_shortpath" = x; then
23035     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23036 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23037     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23038   fi
23039 
23040   # Call helper function which possibly converts this using DOS-style short mode.
23041   # If so, the updated path is stored in $new_path.
23042 
23043   input_path="$new_path"
23044   # Check if we need to convert this using DOS-style short mode. If the path
23045   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23046   # take no chances and rewrite it.
23047   # Note: m4 eats our [], so we need to use [ and ] instead.
23048   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23049   if test "x$has_forbidden_chars" != x; then
23050     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23051     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23052     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23053     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23054       # Going to short mode and back again did indeed matter. Since short mode is
23055       # case insensitive, let's make it lowercase to improve readability.
23056       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23057       # Now convert it back to Unix-style (cygpath)
23058       input_path=`$CYGPATH -u "$shortmode_path"`
23059       new_path="$input_path"
23060     fi
23061   fi
23062 
23063   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23064   if test "x$test_cygdrive_prefix" = x; then
23065     # As a simple fix, exclude /usr/bin since it's not a real path.
23066     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23067       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23068       # a path prefixed by /cygdrive for fixpath to work.
23069       new_path="$CYGWIN_ROOT_PATH$input_path"
23070     fi
23071   fi
23072 
23073 
23074   if test "x$path" != "x$new_path"; then
23075     BOOT_JDK="$new_path"
23076     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23077 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23078   fi
23079 
23080   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23081 
23082   path="$BOOT_JDK"
23083   has_colon=`$ECHO $path | $GREP ^.:`
23084   new_path="$path"
23085   if test "x$has_colon" = x; then
23086     # Not in mixed or Windows style, start by that.
23087     new_path=`cmd //c echo $path`
23088   fi
23089 
23090 
23091   input_path="$new_path"
23092   # Check if we need to convert this using DOS-style short mode. If the path
23093   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23094   # take no chances and rewrite it.
23095   # Note: m4 eats our [], so we need to use [ and ] instead.
23096   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23097   if test "x$has_forbidden_chars" != x; then
23098     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23099     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23100   fi
23101 
23102 
23103   windows_path="$new_path"
23104   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23105     unix_path=`$CYGPATH -u "$windows_path"`
23106     new_path="$unix_path"
23107   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23108     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23109     new_path="$unix_path"
23110   fi
23111 
23112   if test "x$path" != "x$new_path"; then
23113     BOOT_JDK="$new_path"
23114     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23115 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23116   fi
23117 
23118   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23119   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23120 
23121   else
23122     # We're on a posix platform. Hooray! :)
23123     path="$BOOT_JDK"
23124     has_space=`$ECHO "$path" | $GREP " "`
23125     if test "x$has_space" != x; then
23126       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23127 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23128       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23129     fi
23130 
23131     # Use eval to expand a potential ~
23132     eval path="$path"
23133     if test ! -f "$path" && test ! -d "$path"; then
23134       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23135     fi
23136 
23137     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23138   fi
23139 
23140               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23141 $as_echo_n "checking for Boot JDK... " >&6; }
23142               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23143 $as_echo "$BOOT_JDK" >&6; }
23144               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23145 $as_echo_n "checking Boot JDK version... " >&6; }
23146               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23147               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23148 $as_echo "$BOOT_JDK_VERSION" >&6; }
23149             fi # end check jdk version
23150           fi # end check rt.jar
23151         fi # end check javac
23152       fi # end check java
23153     fi # end check boot jdk found
23154   fi
23155 
23156     done
23157   fi
23158 
23159 
23160     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23161     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23162       # Do we have a bin/java?
23163       if test ! -x "$BOOT_JDK/bin/java"; then
23164         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23165 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23166         BOOT_JDK_FOUND=no
23167       else
23168         # Do we have a bin/javac?
23169         if test ! -x "$BOOT_JDK/bin/javac"; then
23170           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23171 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23172           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23173 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23174           BOOT_JDK_FOUND=no
23175         else
23176           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23177           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23178             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23179 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23180             BOOT_JDK_FOUND=no
23181           else
23182             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23183             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23184 
23185             # Extra M4 quote needed to protect [] in grep expression.
23186             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
23187             if test "x$FOUND_VERSION_78" = x; then
23188               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23189 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23190               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
23191 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
23192               BOOT_JDK_FOUND=no
23193             else
23194               # We're done! :-)
23195               BOOT_JDK_FOUND=yes
23196 
23197   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23198 
23199   # Input might be given as Windows format, start by converting to
23200   # unix format.
23201   path="$BOOT_JDK"
23202   new_path=`$CYGPATH -u "$path"`
23203 
23204   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23205   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23206   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23207   # "foo.exe" is OK but "foo" is an error.
23208   #
23209   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23210   # It is also a way to make sure we got the proper file name for the real test later on.
23211   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23212   if test "x$test_shortpath" = x; then
23213     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23214 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23215     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23216   fi
23217 
23218   # Call helper function which possibly converts this using DOS-style short mode.
23219   # If so, the updated path is stored in $new_path.
23220 
23221   input_path="$new_path"
23222   # Check if we need to convert this using DOS-style short mode. If the path
23223   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23224   # take no chances and rewrite it.
23225   # Note: m4 eats our [], so we need to use [ and ] instead.
23226   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23227   if test "x$has_forbidden_chars" != x; then
23228     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23229     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23230     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23231     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23232       # Going to short mode and back again did indeed matter. Since short mode is
23233       # case insensitive, let's make it lowercase to improve readability.
23234       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23235       # Now convert it back to Unix-style (cygpath)
23236       input_path=`$CYGPATH -u "$shortmode_path"`
23237       new_path="$input_path"
23238     fi
23239   fi
23240 
23241   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23242   if test "x$test_cygdrive_prefix" = x; then
23243     # As a simple fix, exclude /usr/bin since it's not a real path.
23244     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23245       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23246       # a path prefixed by /cygdrive for fixpath to work.
23247       new_path="$CYGWIN_ROOT_PATH$input_path"
23248     fi
23249   fi
23250 
23251 
23252   if test "x$path" != "x$new_path"; then
23253     BOOT_JDK="$new_path"
23254     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23255 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23256   fi
23257 
23258   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23259 
23260   path="$BOOT_JDK"
23261   has_colon=`$ECHO $path | $GREP ^.:`
23262   new_path="$path"
23263   if test "x$has_colon" = x; then
23264     # Not in mixed or Windows style, start by that.
23265     new_path=`cmd //c echo $path`
23266   fi
23267 
23268 
23269   input_path="$new_path"
23270   # Check if we need to convert this using DOS-style short mode. If the path
23271   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23272   # take no chances and rewrite it.
23273   # Note: m4 eats our [], so we need to use [ and ] instead.
23274   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23275   if test "x$has_forbidden_chars" != x; then
23276     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23277     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23278   fi
23279 
23280 
23281   windows_path="$new_path"
23282   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23283     unix_path=`$CYGPATH -u "$windows_path"`
23284     new_path="$unix_path"
23285   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23286     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23287     new_path="$unix_path"
23288   fi
23289 
23290   if test "x$path" != "x$new_path"; then
23291     BOOT_JDK="$new_path"
23292     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23293 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23294   fi
23295 
23296   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23297   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23298 
23299   else
23300     # We're on a posix platform. Hooray! :)
23301     path="$BOOT_JDK"
23302     has_space=`$ECHO "$path" | $GREP " "`
23303     if test "x$has_space" != x; then
23304       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23305 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23306       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23307     fi
23308 
23309     # Use eval to expand a potential ~
23310     eval path="$path"
23311     if test ! -f "$path" && test ! -d "$path"; then
23312       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23313     fi
23314 
23315     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23316   fi
23317 
23318               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23319 $as_echo_n "checking for Boot JDK... " >&6; }
23320               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23321 $as_echo "$BOOT_JDK" >&6; }
23322               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23323 $as_echo_n "checking Boot JDK version... " >&6; }
23324               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23325               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23326 $as_echo "$BOOT_JDK_VERSION" >&6; }
23327             fi # end check jdk version
23328           fi # end check rt.jar
23329         fi # end check javac
23330       fi # end check java
23331     fi # end check boot jdk found
23332   fi
23333 
23334   elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
23335 
23336   if test "x$BOOT_JDK_FOUND" = xno; then
23337     # Now execute the test
23338 
23339   BOOT_JDK_PREFIX="/Library/Java/JavaVirtualMachines"
23340   BOOT_JDK_SUFFIX="/Contents/Home"
23341   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23342   if test "x$ALL_JDKS_FOUND" != x; then
23343     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23344 
23345   if test "x$BOOT_JDK_FOUND" = xno; then
23346     # Now execute the test
23347 
23348         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23349         if test -d "$BOOT_JDK"; then
23350           BOOT_JDK_FOUND=maybe
23351           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23352 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23353         fi
23354 
23355 
23356     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23357     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23358       # Do we have a bin/java?
23359       if test ! -x "$BOOT_JDK/bin/java"; then
23360         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23361 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23362         BOOT_JDK_FOUND=no
23363       else
23364         # Do we have a bin/javac?
23365         if test ! -x "$BOOT_JDK/bin/javac"; then
23366           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23367 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23368           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23369 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23370           BOOT_JDK_FOUND=no
23371         else
23372           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23373           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23374             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23375 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23376             BOOT_JDK_FOUND=no
23377           else
23378             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23379             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23380 
23381             # Extra M4 quote needed to protect [] in grep expression.
23382             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
23383             if test "x$FOUND_VERSION_78" = x; then
23384               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23385 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23386               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
23387 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
23388               BOOT_JDK_FOUND=no
23389             else
23390               # We're done! :-)
23391               BOOT_JDK_FOUND=yes
23392 
23393   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23394 
23395   # Input might be given as Windows format, start by converting to
23396   # unix format.
23397   path="$BOOT_JDK"
23398   new_path=`$CYGPATH -u "$path"`
23399 
23400   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23401   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23402   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23403   # "foo.exe" is OK but "foo" is an error.
23404   #
23405   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23406   # It is also a way to make sure we got the proper file name for the real test later on.
23407   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23408   if test "x$test_shortpath" = x; then
23409     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23410 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23411     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23412   fi
23413 
23414   # Call helper function which possibly converts this using DOS-style short mode.
23415   # If so, the updated path is stored in $new_path.
23416 
23417   input_path="$new_path"
23418   # Check if we need to convert this using DOS-style short mode. If the path
23419   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23420   # take no chances and rewrite it.
23421   # Note: m4 eats our [], so we need to use [ and ] instead.
23422   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23423   if test "x$has_forbidden_chars" != x; then
23424     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23425     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23426     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23427     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23428       # Going to short mode and back again did indeed matter. Since short mode is
23429       # case insensitive, let's make it lowercase to improve readability.
23430       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23431       # Now convert it back to Unix-style (cygpath)
23432       input_path=`$CYGPATH -u "$shortmode_path"`
23433       new_path="$input_path"
23434     fi
23435   fi
23436 
23437   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23438   if test "x$test_cygdrive_prefix" = x; then
23439     # As a simple fix, exclude /usr/bin since it's not a real path.
23440     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23441       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23442       # a path prefixed by /cygdrive for fixpath to work.
23443       new_path="$CYGWIN_ROOT_PATH$input_path"
23444     fi
23445   fi
23446 
23447 
23448   if test "x$path" != "x$new_path"; then
23449     BOOT_JDK="$new_path"
23450     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23451 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23452   fi
23453 
23454   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23455 
23456   path="$BOOT_JDK"
23457   has_colon=`$ECHO $path | $GREP ^.:`
23458   new_path="$path"
23459   if test "x$has_colon" = x; then
23460     # Not in mixed or Windows style, start by that.
23461     new_path=`cmd //c echo $path`
23462   fi
23463 
23464 
23465   input_path="$new_path"
23466   # Check if we need to convert this using DOS-style short mode. If the path
23467   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23468   # take no chances and rewrite it.
23469   # Note: m4 eats our [], so we need to use [ and ] instead.
23470   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23471   if test "x$has_forbidden_chars" != x; then
23472     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23473     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23474   fi
23475 
23476 
23477   windows_path="$new_path"
23478   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23479     unix_path=`$CYGPATH -u "$windows_path"`
23480     new_path="$unix_path"
23481   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23482     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23483     new_path="$unix_path"
23484   fi
23485 
23486   if test "x$path" != "x$new_path"; then
23487     BOOT_JDK="$new_path"
23488     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23489 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23490   fi
23491 
23492   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23493   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23494 
23495   else
23496     # We're on a posix platform. Hooray! :)
23497     path="$BOOT_JDK"
23498     has_space=`$ECHO "$path" | $GREP " "`
23499     if test "x$has_space" != x; then
23500       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23501 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23502       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23503     fi
23504 
23505     # Use eval to expand a potential ~
23506     eval path="$path"
23507     if test ! -f "$path" && test ! -d "$path"; then
23508       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23509     fi
23510 
23511     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23512   fi
23513 
23514               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23515 $as_echo_n "checking for Boot JDK... " >&6; }
23516               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23517 $as_echo "$BOOT_JDK" >&6; }
23518               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23519 $as_echo_n "checking Boot JDK version... " >&6; }
23520               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23521               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23522 $as_echo "$BOOT_JDK_VERSION" >&6; }
23523             fi # end check jdk version
23524           fi # end check rt.jar
23525         fi # end check javac
23526       fi # end check java
23527     fi # end check boot jdk found
23528   fi
23529 
23530     done
23531   fi
23532 
23533 
23534     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23535     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23536       # Do we have a bin/java?
23537       if test ! -x "$BOOT_JDK/bin/java"; then
23538         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23539 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23540         BOOT_JDK_FOUND=no
23541       else
23542         # Do we have a bin/javac?
23543         if test ! -x "$BOOT_JDK/bin/javac"; then
23544           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23545 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23546           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23547 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23548           BOOT_JDK_FOUND=no
23549         else
23550           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23551           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23552             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23553 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23554             BOOT_JDK_FOUND=no
23555           else
23556             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23557             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23558 
23559             # Extra M4 quote needed to protect [] in grep expression.
23560             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
23561             if test "x$FOUND_VERSION_78" = x; then
23562               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23563 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23564               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
23565 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
23566               BOOT_JDK_FOUND=no
23567             else
23568               # We're done! :-)
23569               BOOT_JDK_FOUND=yes
23570 
23571   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23572 
23573   # Input might be given as Windows format, start by converting to
23574   # unix format.
23575   path="$BOOT_JDK"
23576   new_path=`$CYGPATH -u "$path"`
23577 
23578   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23579   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23580   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23581   # "foo.exe" is OK but "foo" is an error.
23582   #
23583   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23584   # It is also a way to make sure we got the proper file name for the real test later on.
23585   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23586   if test "x$test_shortpath" = x; then
23587     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23588 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23589     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23590   fi
23591 
23592   # Call helper function which possibly converts this using DOS-style short mode.
23593   # If so, the updated path is stored in $new_path.
23594 
23595   input_path="$new_path"
23596   # Check if we need to convert this using DOS-style short mode. If the path
23597   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23598   # take no chances and rewrite it.
23599   # Note: m4 eats our [], so we need to use [ and ] instead.
23600   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23601   if test "x$has_forbidden_chars" != x; then
23602     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23603     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23604     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23605     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23606       # Going to short mode and back again did indeed matter. Since short mode is
23607       # case insensitive, let's make it lowercase to improve readability.
23608       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23609       # Now convert it back to Unix-style (cygpath)
23610       input_path=`$CYGPATH -u "$shortmode_path"`
23611       new_path="$input_path"
23612     fi
23613   fi
23614 
23615   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23616   if test "x$test_cygdrive_prefix" = x; then
23617     # As a simple fix, exclude /usr/bin since it's not a real path.
23618     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23619       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23620       # a path prefixed by /cygdrive for fixpath to work.
23621       new_path="$CYGWIN_ROOT_PATH$input_path"
23622     fi
23623   fi
23624 
23625 
23626   if test "x$path" != "x$new_path"; then
23627     BOOT_JDK="$new_path"
23628     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23629 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23630   fi
23631 
23632   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23633 
23634   path="$BOOT_JDK"
23635   has_colon=`$ECHO $path | $GREP ^.:`
23636   new_path="$path"
23637   if test "x$has_colon" = x; then
23638     # Not in mixed or Windows style, start by that.
23639     new_path=`cmd //c echo $path`
23640   fi
23641 
23642 
23643   input_path="$new_path"
23644   # Check if we need to convert this using DOS-style short mode. If the path
23645   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23646   # take no chances and rewrite it.
23647   # Note: m4 eats our [], so we need to use [ and ] instead.
23648   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23649   if test "x$has_forbidden_chars" != x; then
23650     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23651     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23652   fi
23653 
23654 
23655   windows_path="$new_path"
23656   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23657     unix_path=`$CYGPATH -u "$windows_path"`
23658     new_path="$unix_path"
23659   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23660     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23661     new_path="$unix_path"
23662   fi
23663 
23664   if test "x$path" != "x$new_path"; then
23665     BOOT_JDK="$new_path"
23666     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23667 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23668   fi
23669 
23670   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23671   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23672 
23673   else
23674     # We're on a posix platform. Hooray! :)
23675     path="$BOOT_JDK"
23676     has_space=`$ECHO "$path" | $GREP " "`
23677     if test "x$has_space" != x; then
23678       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23679 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23680       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23681     fi
23682 
23683     # Use eval to expand a potential ~
23684     eval path="$path"
23685     if test ! -f "$path" && test ! -d "$path"; then
23686       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23687     fi
23688 
23689     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23690   fi
23691 
23692               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23693 $as_echo_n "checking for Boot JDK... " >&6; }
23694               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23695 $as_echo "$BOOT_JDK" >&6; }
23696               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23697 $as_echo_n "checking Boot JDK version... " >&6; }
23698               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23699               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23700 $as_echo "$BOOT_JDK_VERSION" >&6; }
23701             fi # end check jdk version
23702           fi # end check rt.jar
23703         fi # end check javac
23704       fi # end check java
23705     fi # end check boot jdk found
23706   fi
23707 
23708 
23709   if test "x$BOOT_JDK_FOUND" = xno; then
23710     # Now execute the test
23711 
23712   BOOT_JDK_PREFIX="/System/Library/Java/JavaVirtualMachines"
23713   BOOT_JDK_SUFFIX="/Contents/Home"
23714   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23715   if test "x$ALL_JDKS_FOUND" != x; then
23716     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23717 
23718   if test "x$BOOT_JDK_FOUND" = xno; then
23719     # Now execute the test
23720 
23721         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23722         if test -d "$BOOT_JDK"; then
23723           BOOT_JDK_FOUND=maybe
23724           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23725 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23726         fi
23727 
23728 
23729     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23730     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23731       # Do we have a bin/java?
23732       if test ! -x "$BOOT_JDK/bin/java"; then
23733         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23734 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23735         BOOT_JDK_FOUND=no
23736       else
23737         # Do we have a bin/javac?
23738         if test ! -x "$BOOT_JDK/bin/javac"; then
23739           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23740 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23741           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23742 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23743           BOOT_JDK_FOUND=no
23744         else
23745           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23746           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23747             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23748 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23749             BOOT_JDK_FOUND=no
23750           else
23751             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23752             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23753 
23754             # Extra M4 quote needed to protect [] in grep expression.
23755             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
23756             if test "x$FOUND_VERSION_78" = x; then
23757               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23758 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23759               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
23760 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
23761               BOOT_JDK_FOUND=no
23762             else
23763               # We're done! :-)
23764               BOOT_JDK_FOUND=yes
23765 
23766   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23767 
23768   # Input might be given as Windows format, start by converting to
23769   # unix format.
23770   path="$BOOT_JDK"
23771   new_path=`$CYGPATH -u "$path"`
23772 
23773   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23774   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23775   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23776   # "foo.exe" is OK but "foo" is an error.
23777   #
23778   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23779   # It is also a way to make sure we got the proper file name for the real test later on.
23780   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23781   if test "x$test_shortpath" = x; then
23782     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23783 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23784     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23785   fi
23786 
23787   # Call helper function which possibly converts this using DOS-style short mode.
23788   # If so, the updated path is stored in $new_path.
23789 
23790   input_path="$new_path"
23791   # Check if we need to convert this using DOS-style short mode. If the path
23792   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23793   # take no chances and rewrite it.
23794   # Note: m4 eats our [], so we need to use [ and ] instead.
23795   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23796   if test "x$has_forbidden_chars" != x; then
23797     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23798     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23799     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23800     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23801       # Going to short mode and back again did indeed matter. Since short mode is
23802       # case insensitive, let's make it lowercase to improve readability.
23803       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23804       # Now convert it back to Unix-style (cygpath)
23805       input_path=`$CYGPATH -u "$shortmode_path"`
23806       new_path="$input_path"
23807     fi
23808   fi
23809 
23810   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23811   if test "x$test_cygdrive_prefix" = x; then
23812     # As a simple fix, exclude /usr/bin since it's not a real path.
23813     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23814       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23815       # a path prefixed by /cygdrive for fixpath to work.
23816       new_path="$CYGWIN_ROOT_PATH$input_path"
23817     fi
23818   fi
23819 
23820 
23821   if test "x$path" != "x$new_path"; then
23822     BOOT_JDK="$new_path"
23823     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23824 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23825   fi
23826 
23827   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23828 
23829   path="$BOOT_JDK"
23830   has_colon=`$ECHO $path | $GREP ^.:`
23831   new_path="$path"
23832   if test "x$has_colon" = x; then
23833     # Not in mixed or Windows style, start by that.
23834     new_path=`cmd //c echo $path`
23835   fi
23836 
23837 
23838   input_path="$new_path"
23839   # Check if we need to convert this using DOS-style short mode. If the path
23840   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23841   # take no chances and rewrite it.
23842   # Note: m4 eats our [], so we need to use [ and ] instead.
23843   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23844   if test "x$has_forbidden_chars" != x; then
23845     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23846     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23847   fi
23848 
23849 
23850   windows_path="$new_path"
23851   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23852     unix_path=`$CYGPATH -u "$windows_path"`
23853     new_path="$unix_path"
23854   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23855     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23856     new_path="$unix_path"
23857   fi
23858 
23859   if test "x$path" != "x$new_path"; then
23860     BOOT_JDK="$new_path"
23861     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23862 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23863   fi
23864 
23865   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23866   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23867 
23868   else
23869     # We're on a posix platform. Hooray! :)
23870     path="$BOOT_JDK"
23871     has_space=`$ECHO "$path" | $GREP " "`
23872     if test "x$has_space" != x; then
23873       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23874 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23875       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23876     fi
23877 
23878     # Use eval to expand a potential ~
23879     eval path="$path"
23880     if test ! -f "$path" && test ! -d "$path"; then
23881       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23882     fi
23883 
23884     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23885   fi
23886 
23887               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23888 $as_echo_n "checking for Boot JDK... " >&6; }
23889               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23890 $as_echo "$BOOT_JDK" >&6; }
23891               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23892 $as_echo_n "checking Boot JDK version... " >&6; }
23893               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23894               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23895 $as_echo "$BOOT_JDK_VERSION" >&6; }
23896             fi # end check jdk version
23897           fi # end check rt.jar
23898         fi # end check javac
23899       fi # end check java
23900     fi # end check boot jdk found
23901   fi
23902 
23903     done
23904   fi
23905 
23906 
23907     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23908     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23909       # Do we have a bin/java?
23910       if test ! -x "$BOOT_JDK/bin/java"; then
23911         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23912 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23913         BOOT_JDK_FOUND=no
23914       else
23915         # Do we have a bin/javac?
23916         if test ! -x "$BOOT_JDK/bin/javac"; then
23917           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23918 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23919           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23920 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23921           BOOT_JDK_FOUND=no
23922         else
23923           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
23924           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
23925             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
23926 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
23927             BOOT_JDK_FOUND=no
23928           else
23929             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23930             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23931 
23932             # Extra M4 quote needed to protect [] in grep expression.
23933             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
23934             if test "x$FOUND_VERSION_78" = x; then
23935               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23936 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23937               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
23938 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
23939               BOOT_JDK_FOUND=no
23940             else
23941               # We're done! :-)
23942               BOOT_JDK_FOUND=yes
23943 
23944   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23945 
23946   # Input might be given as Windows format, start by converting to
23947   # unix format.
23948   path="$BOOT_JDK"
23949   new_path=`$CYGPATH -u "$path"`
23950 
23951   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23952   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23953   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23954   # "foo.exe" is OK but "foo" is an error.
23955   #
23956   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23957   # It is also a way to make sure we got the proper file name for the real test later on.
23958   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23959   if test "x$test_shortpath" = x; then
23960     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23961 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23962     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23963   fi
23964 
23965   # Call helper function which possibly converts this using DOS-style short mode.
23966   # If so, the updated path is stored in $new_path.
23967 
23968   input_path="$new_path"
23969   # Check if we need to convert this using DOS-style short mode. If the path
23970   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23971   # take no chances and rewrite it.
23972   # Note: m4 eats our [], so we need to use [ and ] instead.
23973   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23974   if test "x$has_forbidden_chars" != x; then
23975     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23976     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23977     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23978     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23979       # Going to short mode and back again did indeed matter. Since short mode is
23980       # case insensitive, let's make it lowercase to improve readability.
23981       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23982       # Now convert it back to Unix-style (cygpath)
23983       input_path=`$CYGPATH -u "$shortmode_path"`
23984       new_path="$input_path"
23985     fi
23986   fi
23987 
23988   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23989   if test "x$test_cygdrive_prefix" = x; then
23990     # As a simple fix, exclude /usr/bin since it's not a real path.
23991     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23992       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23993       # a path prefixed by /cygdrive for fixpath to work.
23994       new_path="$CYGWIN_ROOT_PATH$input_path"
23995     fi
23996   fi
23997 
23998 
23999   if test "x$path" != "x$new_path"; then
24000     BOOT_JDK="$new_path"
24001     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24002 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24003   fi
24004 
24005   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24006 
24007   path="$BOOT_JDK"
24008   has_colon=`$ECHO $path | $GREP ^.:`
24009   new_path="$path"
24010   if test "x$has_colon" = x; then
24011     # Not in mixed or Windows style, start by that.
24012     new_path=`cmd //c echo $path`
24013   fi
24014 
24015 
24016   input_path="$new_path"
24017   # Check if we need to convert this using DOS-style short mode. If the path
24018   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24019   # take no chances and rewrite it.
24020   # Note: m4 eats our [], so we need to use [ and ] instead.
24021   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24022   if test "x$has_forbidden_chars" != x; then
24023     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24024     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24025   fi
24026 
24027 
24028   windows_path="$new_path"
24029   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24030     unix_path=`$CYGPATH -u "$windows_path"`
24031     new_path="$unix_path"
24032   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24033     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24034     new_path="$unix_path"
24035   fi
24036 
24037   if test "x$path" != "x$new_path"; then
24038     BOOT_JDK="$new_path"
24039     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24040 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24041   fi
24042 
24043   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24044   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24045 
24046   else
24047     # We're on a posix platform. Hooray! :)
24048     path="$BOOT_JDK"
24049     has_space=`$ECHO "$path" | $GREP " "`
24050     if test "x$has_space" != x; then
24051       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24052 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24053       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24054     fi
24055 
24056     # Use eval to expand a potential ~
24057     eval path="$path"
24058     if test ! -f "$path" && test ! -d "$path"; then
24059       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24060     fi
24061 
24062     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24063   fi
24064 
24065               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24066 $as_echo_n "checking for Boot JDK... " >&6; }
24067               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24068 $as_echo "$BOOT_JDK" >&6; }
24069               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24070 $as_echo_n "checking Boot JDK version... " >&6; }
24071               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24072               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24073 $as_echo "$BOOT_JDK_VERSION" >&6; }
24074             fi # end check jdk version
24075           fi # end check rt.jar
24076         fi # end check javac
24077       fi # end check java
24078     fi # end check boot jdk found
24079   fi
24080 
24081   elif test "x$OPENJDK_TARGET_OS" = xlinux; then
24082 
24083   if test "x$BOOT_JDK_FOUND" = xno; then
24084     # Now execute the test
24085 
24086   BOOT_JDK_PREFIX="/usr/lib/jvm"
24087   BOOT_JDK_SUFFIX=""
24088   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24089   if test "x$ALL_JDKS_FOUND" != x; then
24090     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24091 
24092   if test "x$BOOT_JDK_FOUND" = xno; then
24093     # Now execute the test
24094 
24095         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24096         if test -d "$BOOT_JDK"; then
24097           BOOT_JDK_FOUND=maybe
24098           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24099 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24100         fi
24101 
24102 
24103     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24104     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24105       # Do we have a bin/java?
24106       if test ! -x "$BOOT_JDK/bin/java"; then
24107         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24108 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24109         BOOT_JDK_FOUND=no
24110       else
24111         # Do we have a bin/javac?
24112         if test ! -x "$BOOT_JDK/bin/javac"; then
24113           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24114 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24115           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24116 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24117           BOOT_JDK_FOUND=no
24118         else
24119           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
24120           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
24121             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
24122 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
24123             BOOT_JDK_FOUND=no
24124           else
24125             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24126             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24127 
24128             # Extra M4 quote needed to protect [] in grep expression.
24129             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
24130             if test "x$FOUND_VERSION_78" = x; then
24131               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24132 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24133               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
24134 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
24135               BOOT_JDK_FOUND=no
24136             else
24137               # We're done! :-)
24138               BOOT_JDK_FOUND=yes
24139 
24140   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24141 
24142   # Input might be given as Windows format, start by converting to
24143   # unix format.
24144   path="$BOOT_JDK"
24145   new_path=`$CYGPATH -u "$path"`
24146 
24147   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24148   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24149   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24150   # "foo.exe" is OK but "foo" is an error.
24151   #
24152   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24153   # It is also a way to make sure we got the proper file name for the real test later on.
24154   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24155   if test "x$test_shortpath" = x; then
24156     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24157 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24158     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24159   fi
24160 
24161   # Call helper function which possibly converts this using DOS-style short mode.
24162   # If so, the updated path is stored in $new_path.
24163 
24164   input_path="$new_path"
24165   # Check if we need to convert this using DOS-style short mode. If the path
24166   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24167   # take no chances and rewrite it.
24168   # Note: m4 eats our [], so we need to use [ and ] instead.
24169   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24170   if test "x$has_forbidden_chars" != x; then
24171     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24172     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24173     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24174     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24175       # Going to short mode and back again did indeed matter. Since short mode is
24176       # case insensitive, let's make it lowercase to improve readability.
24177       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24178       # Now convert it back to Unix-style (cygpath)
24179       input_path=`$CYGPATH -u "$shortmode_path"`
24180       new_path="$input_path"
24181     fi
24182   fi
24183 
24184   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24185   if test "x$test_cygdrive_prefix" = x; then
24186     # As a simple fix, exclude /usr/bin since it's not a real path.
24187     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24188       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24189       # a path prefixed by /cygdrive for fixpath to work.
24190       new_path="$CYGWIN_ROOT_PATH$input_path"
24191     fi
24192   fi
24193 
24194 
24195   if test "x$path" != "x$new_path"; then
24196     BOOT_JDK="$new_path"
24197     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24198 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24199   fi
24200 
24201   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24202 
24203   path="$BOOT_JDK"
24204   has_colon=`$ECHO $path | $GREP ^.:`
24205   new_path="$path"
24206   if test "x$has_colon" = x; then
24207     # Not in mixed or Windows style, start by that.
24208     new_path=`cmd //c echo $path`
24209   fi
24210 
24211 
24212   input_path="$new_path"
24213   # Check if we need to convert this using DOS-style short mode. If the path
24214   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24215   # take no chances and rewrite it.
24216   # Note: m4 eats our [], so we need to use [ and ] instead.
24217   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24218   if test "x$has_forbidden_chars" != x; then
24219     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24220     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24221   fi
24222 
24223 
24224   windows_path="$new_path"
24225   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24226     unix_path=`$CYGPATH -u "$windows_path"`
24227     new_path="$unix_path"
24228   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24229     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24230     new_path="$unix_path"
24231   fi
24232 
24233   if test "x$path" != "x$new_path"; then
24234     BOOT_JDK="$new_path"
24235     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24236 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24237   fi
24238 
24239   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24240   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24241 
24242   else
24243     # We're on a posix platform. Hooray! :)
24244     path="$BOOT_JDK"
24245     has_space=`$ECHO "$path" | $GREP " "`
24246     if test "x$has_space" != x; then
24247       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24248 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24249       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24250     fi
24251 
24252     # Use eval to expand a potential ~
24253     eval path="$path"
24254     if test ! -f "$path" && test ! -d "$path"; then
24255       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24256     fi
24257 
24258     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24259   fi
24260 
24261               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24262 $as_echo_n "checking for Boot JDK... " >&6; }
24263               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24264 $as_echo "$BOOT_JDK" >&6; }
24265               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24266 $as_echo_n "checking Boot JDK version... " >&6; }
24267               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24268               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24269 $as_echo "$BOOT_JDK_VERSION" >&6; }
24270             fi # end check jdk version
24271           fi # end check rt.jar
24272         fi # end check javac
24273       fi # end check java
24274     fi # end check boot jdk found
24275   fi
24276 
24277     done
24278   fi
24279 
24280 
24281     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24282     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24283       # Do we have a bin/java?
24284       if test ! -x "$BOOT_JDK/bin/java"; then
24285         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24286 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24287         BOOT_JDK_FOUND=no
24288       else
24289         # Do we have a bin/javac?
24290         if test ! -x "$BOOT_JDK/bin/javac"; then
24291           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24292 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24293           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24294 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24295           BOOT_JDK_FOUND=no
24296         else
24297           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
24298           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
24299             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
24300 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
24301             BOOT_JDK_FOUND=no
24302           else
24303             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24304             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24305 
24306             # Extra M4 quote needed to protect [] in grep expression.
24307             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
24308             if test "x$FOUND_VERSION_78" = x; then
24309               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24310 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24311               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
24312 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
24313               BOOT_JDK_FOUND=no
24314             else
24315               # We're done! :-)
24316               BOOT_JDK_FOUND=yes
24317 
24318   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24319 
24320   # Input might be given as Windows format, start by converting to
24321   # unix format.
24322   path="$BOOT_JDK"
24323   new_path=`$CYGPATH -u "$path"`
24324 
24325   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24326   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24327   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24328   # "foo.exe" is OK but "foo" is an error.
24329   #
24330   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24331   # It is also a way to make sure we got the proper file name for the real test later on.
24332   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24333   if test "x$test_shortpath" = x; then
24334     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24335 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24336     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24337   fi
24338 
24339   # Call helper function which possibly converts this using DOS-style short mode.
24340   # If so, the updated path is stored in $new_path.
24341 
24342   input_path="$new_path"
24343   # Check if we need to convert this using DOS-style short mode. If the path
24344   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24345   # take no chances and rewrite it.
24346   # Note: m4 eats our [], so we need to use [ and ] instead.
24347   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24348   if test "x$has_forbidden_chars" != x; then
24349     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24350     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24351     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24352     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24353       # Going to short mode and back again did indeed matter. Since short mode is
24354       # case insensitive, let's make it lowercase to improve readability.
24355       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24356       # Now convert it back to Unix-style (cygpath)
24357       input_path=`$CYGPATH -u "$shortmode_path"`
24358       new_path="$input_path"
24359     fi
24360   fi
24361 
24362   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24363   if test "x$test_cygdrive_prefix" = x; then
24364     # As a simple fix, exclude /usr/bin since it's not a real path.
24365     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24366       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24367       # a path prefixed by /cygdrive for fixpath to work.
24368       new_path="$CYGWIN_ROOT_PATH$input_path"
24369     fi
24370   fi
24371 
24372 
24373   if test "x$path" != "x$new_path"; then
24374     BOOT_JDK="$new_path"
24375     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24376 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24377   fi
24378 
24379   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24380 
24381   path="$BOOT_JDK"
24382   has_colon=`$ECHO $path | $GREP ^.:`
24383   new_path="$path"
24384   if test "x$has_colon" = x; then
24385     # Not in mixed or Windows style, start by that.
24386     new_path=`cmd //c echo $path`
24387   fi
24388 
24389 
24390   input_path="$new_path"
24391   # Check if we need to convert this using DOS-style short mode. If the path
24392   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24393   # take no chances and rewrite it.
24394   # Note: m4 eats our [], so we need to use [ and ] instead.
24395   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24396   if test "x$has_forbidden_chars" != x; then
24397     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24398     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24399   fi
24400 
24401 
24402   windows_path="$new_path"
24403   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24404     unix_path=`$CYGPATH -u "$windows_path"`
24405     new_path="$unix_path"
24406   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24407     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24408     new_path="$unix_path"
24409   fi
24410 
24411   if test "x$path" != "x$new_path"; then
24412     BOOT_JDK="$new_path"
24413     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24414 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24415   fi
24416 
24417   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24418   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24419 
24420   else
24421     # We're on a posix platform. Hooray! :)
24422     path="$BOOT_JDK"
24423     has_space=`$ECHO "$path" | $GREP " "`
24424     if test "x$has_space" != x; then
24425       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24426 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24427       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24428     fi
24429 
24430     # Use eval to expand a potential ~
24431     eval path="$path"
24432     if test ! -f "$path" && test ! -d "$path"; then
24433       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24434     fi
24435 
24436     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24437   fi
24438 
24439               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24440 $as_echo_n "checking for Boot JDK... " >&6; }
24441               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24442 $as_echo "$BOOT_JDK" >&6; }
24443               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24444 $as_echo_n "checking Boot JDK version... " >&6; }
24445               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24446               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24447 $as_echo "$BOOT_JDK_VERSION" >&6; }
24448             fi # end check jdk version
24449           fi # end check rt.jar
24450         fi # end check javac
24451       fi # end check java
24452     fi # end check boot jdk found
24453   fi
24454 
24455   fi
24456 
24457 
24458     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24459     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24460       # Do we have a bin/java?
24461       if test ! -x "$BOOT_JDK/bin/java"; then
24462         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24463 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24464         BOOT_JDK_FOUND=no
24465       else
24466         # Do we have a bin/javac?
24467         if test ! -x "$BOOT_JDK/bin/javac"; then
24468           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24469 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24470           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24471 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24472           BOOT_JDK_FOUND=no
24473         else
24474           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
24475           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
24476             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
24477 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
24478             BOOT_JDK_FOUND=no
24479           else
24480             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24481             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24482 
24483             # Extra M4 quote needed to protect [] in grep expression.
24484             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
24485             if test "x$FOUND_VERSION_78" = x; then
24486               { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24487 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24488               { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
24489 $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
24490               BOOT_JDK_FOUND=no
24491             else
24492               # We're done! :-)
24493               BOOT_JDK_FOUND=yes
24494 
24495   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24496 
24497   # Input might be given as Windows format, start by converting to
24498   # unix format.
24499   path="$BOOT_JDK"
24500   new_path=`$CYGPATH -u "$path"`
24501 
24502   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24503   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24504   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24505   # "foo.exe" is OK but "foo" is an error.
24506   #
24507   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24508   # It is also a way to make sure we got the proper file name for the real test later on.
24509   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24510   if test "x$test_shortpath" = x; then
24511     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24512 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24513     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24514   fi
24515 
24516   # Call helper function which possibly converts this using DOS-style short mode.
24517   # If so, the updated path is stored in $new_path.
24518 
24519   input_path="$new_path"
24520   # Check if we need to convert this using DOS-style short mode. If the path
24521   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24522   # take no chances and rewrite it.
24523   # Note: m4 eats our [], so we need to use [ and ] instead.
24524   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24525   if test "x$has_forbidden_chars" != x; then
24526     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24527     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24528     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24529     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24530       # Going to short mode and back again did indeed matter. Since short mode is
24531       # case insensitive, let's make it lowercase to improve readability.
24532       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24533       # Now convert it back to Unix-style (cygpath)
24534       input_path=`$CYGPATH -u "$shortmode_path"`
24535       new_path="$input_path"
24536     fi
24537   fi
24538 
24539   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24540   if test "x$test_cygdrive_prefix" = x; then
24541     # As a simple fix, exclude /usr/bin since it's not a real path.
24542     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24543       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24544       # a path prefixed by /cygdrive for fixpath to work.
24545       new_path="$CYGWIN_ROOT_PATH$input_path"
24546     fi
24547   fi
24548 
24549 
24550   if test "x$path" != "x$new_path"; then
24551     BOOT_JDK="$new_path"
24552     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24553 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24554   fi
24555 
24556   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24557 
24558   path="$BOOT_JDK"
24559   has_colon=`$ECHO $path | $GREP ^.:`
24560   new_path="$path"
24561   if test "x$has_colon" = x; then
24562     # Not in mixed or Windows style, start by that.
24563     new_path=`cmd //c echo $path`
24564   fi
24565 
24566 
24567   input_path="$new_path"
24568   # Check if we need to convert this using DOS-style short mode. If the path
24569   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24570   # take no chances and rewrite it.
24571   # Note: m4 eats our [], so we need to use [ and ] instead.
24572   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24573   if test "x$has_forbidden_chars" != x; then
24574     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24575     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24576   fi
24577 
24578 
24579   windows_path="$new_path"
24580   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24581     unix_path=`$CYGPATH -u "$windows_path"`
24582     new_path="$unix_path"
24583   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24584     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24585     new_path="$unix_path"
24586   fi
24587 
24588   if test "x$path" != "x$new_path"; then
24589     BOOT_JDK="$new_path"
24590     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24591 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24592   fi
24593 
24594   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24595   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24596 
24597   else
24598     # We're on a posix platform. Hooray! :)
24599     path="$BOOT_JDK"
24600     has_space=`$ECHO "$path" | $GREP " "`
24601     if test "x$has_space" != x; then
24602       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24603 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24604       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24605     fi
24606 
24607     # Use eval to expand a potential ~
24608     eval path="$path"
24609     if test ! -f "$path" && test ! -d "$path"; then
24610       as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24611     fi
24612 
24613     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24614   fi
24615 
24616               { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24617 $as_echo_n "checking for Boot JDK... " >&6; }
24618               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24619 $as_echo "$BOOT_JDK" >&6; }
24620               { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24621 $as_echo_n "checking Boot JDK version... " >&6; }
24622               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24623               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24624 $as_echo "$BOOT_JDK_VERSION" >&6; }
24625             fi # end check jdk version
24626           fi # end check rt.jar
24627         fi # end check javac
24628       fi # end check java
24629     fi # end check boot jdk found
24630   fi
24631 
24632 
24633   # If we haven't found anything yet, we've truly lost. Give up.
24634   if test "x$BOOT_JDK_FOUND" = xno; then
24635 
24636   # Print a helpful message on how to acquire the necessary build dependency.
24637   # openjdk is the help tag: freetype, cups, pulse, alsa etc
24638   MISSING_DEPENDENCY=openjdk
24639 
24640   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24641     cygwin_help $MISSING_DEPENDENCY
24642   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24643     msys_help $MISSING_DEPENDENCY
24644   else
24645     PKGHANDLER_COMMAND=
24646 
24647     case $PKGHANDLER in
24648       apt-get)
24649         apt_help     $MISSING_DEPENDENCY ;;
24650       yum)
24651         yum_help     $MISSING_DEPENDENCY ;;
24652       port)
24653         port_help    $MISSING_DEPENDENCY ;;
24654       pkgutil)
24655         pkgutil_help $MISSING_DEPENDENCY ;;
24656       pkgadd)
24657         pkgadd_help  $MISSING_DEPENDENCY ;;
24658     esac
24659 
24660     if test "x$PKGHANDLER_COMMAND" != x; then
24661       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
24662     fi
24663   fi
24664 
24665     { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find a valid Boot JDK. $HELP_MSG" >&5
24666 $as_echo "$as_me: Could not find a valid Boot JDK. $HELP_MSG" >&6;}
24667     { $as_echo "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitely setting --with-boot-jdk" >&5
24668 $as_echo "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&6;}
24669     as_fn_error $? "Cannot continue" "$LINENO" 5
24670   fi
24671 
24672   # Setup proper paths for what we found
24673   BOOT_RTJAR="$BOOT_JDK/jre/lib/rt.jar"
24674   if test ! -f "$BOOT_RTJAR"; then
24675     # On MacOSX it is called classes.jar
24676     BOOT_RTJAR="$BOOT_JDK/../Classes/classes.jar"
24677     if test -f "$BOOT_RTJAR"; then
24678       # Remove the ..
24679       BOOT_RTJAR="`cd ${BOOT_RTJAR%/*} && pwd`/${BOOT_RTJAR##*/}"
24680     fi
24681   fi
24682   BOOT_TOOLSJAR="$BOOT_JDK/lib/tools.jar"
24683   BOOT_JDK="$BOOT_JDK"
24684 
24685 
24686 
24687 
24688   # Setup tools from the Boot JDK.
24689 
24690   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for java in Boot JDK" >&5
24691 $as_echo_n "checking for java in Boot JDK... " >&6; }
24692   JAVA=$BOOT_JDK/bin/java
24693   if test ! -x $JAVA; then
24694     { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
24695 $as_echo "not found" >&6; }
24696     { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
24697 $as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
24698     as_fn_error $? "Could not find java in the Boot JDK" "$LINENO" 5
24699   fi
24700   { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
24701 $as_echo "ok" >&6; }
24702 
24703 
24704   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for javac in Boot JDK" >&5
24705 $as_echo_n "checking for javac in Boot JDK... " >&6; }
24706   JAVAC=$BOOT_JDK/bin/javac
24707   if test ! -x $JAVAC; then
24708     { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
24709 $as_echo "not found" >&6; }
24710     { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
24711 $as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
24712     as_fn_error $? "Could not find javac in the Boot JDK" "$LINENO" 5
24713   fi
24714   { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
24715 $as_echo "ok" >&6; }
24716 
24717 
24718   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for javah in Boot JDK" >&5
24719 $as_echo_n "checking for javah in Boot JDK... " >&6; }
24720   JAVAH=$BOOT_JDK/bin/javah
24721   if test ! -x $JAVAH; then
24722     { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
24723 $as_echo "not found" >&6; }
24724     { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
24725 $as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
24726     as_fn_error $? "Could not find javah in the Boot JDK" "$LINENO" 5
24727   fi
24728   { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
24729 $as_echo "ok" >&6; }
24730 
24731 
24732   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for javap in Boot JDK" >&5
24733 $as_echo_n "checking for javap in Boot JDK... " >&6; }
24734   JAVAP=$BOOT_JDK/bin/javap
24735   if test ! -x $JAVAP; then
24736     { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
24737 $as_echo "not found" >&6; }
24738     { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
24739 $as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
24740     as_fn_error $? "Could not find javap in the Boot JDK" "$LINENO" 5
24741   fi
24742   { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
24743 $as_echo "ok" >&6; }
24744 
24745 
24746   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for jar in Boot JDK" >&5
24747 $as_echo_n "checking for jar in Boot JDK... " >&6; }
24748   JAR=$BOOT_JDK/bin/jar
24749   if test ! -x $JAR; then
24750     { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
24751 $as_echo "not found" >&6; }
24752     { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
24753 $as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
24754     as_fn_error $? "Could not find jar in the Boot JDK" "$LINENO" 5
24755   fi
24756   { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
24757 $as_echo "ok" >&6; }
24758 
24759 
24760   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for rmic in Boot JDK" >&5
24761 $as_echo_n "checking for rmic in Boot JDK... " >&6; }
24762   RMIC=$BOOT_JDK/bin/rmic
24763   if test ! -x $RMIC; then
24764     { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
24765 $as_echo "not found" >&6; }
24766     { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
24767 $as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
24768     as_fn_error $? "Could not find rmic in the Boot JDK" "$LINENO" 5
24769   fi
24770   { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
24771 $as_echo "ok" >&6; }
24772 
24773 
24774   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for native2ascii in Boot JDK" >&5
24775 $as_echo_n "checking for native2ascii in Boot JDK... " >&6; }
24776   NATIVE2ASCII=$BOOT_JDK/bin/native2ascii
24777   if test ! -x $NATIVE2ASCII; then
24778     { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
24779 $as_echo "not found" >&6; }
24780     { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
24781 $as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
24782     as_fn_error $? "Could not find native2ascii in the Boot JDK" "$LINENO" 5
24783   fi
24784   { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
24785 $as_echo "ok" >&6; }
24786 
24787 
24788   # Finally, set some other options...
24789 
24790   # When compiling code to be executed by the Boot JDK, force jdk7 compatibility.
24791   BOOT_JDK_SOURCETARGET="-source 7 -target 7"
24792 
24793 
24794 
24795   # Check if the boot jdk is 32 or 64 bit
24796   if "$JAVA" -d64 -version > /dev/null 2>&1; then
24797     BOOT_JDK_BITS="64"
24798   else
24799     BOOT_JDK_BITS="32"
24800   fi
24801   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if Boot JDK is 32 or 64 bits" >&5
24802 $as_echo_n "checking if Boot JDK is 32 or 64 bits... " >&6; }
24803   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_BITS" >&5
24804 $as_echo "$BOOT_JDK_BITS" >&6; }
24805 
24806 
24807 
24808   ##############################################################################
24809   #
24810   # Specify options for anything that is run with the Boot JDK.
24811   #
24812 
24813 # Check whether --with-boot-jdk-jvmargs was given.
24814 if test "${with_boot_jdk_jvmargs+set}" = set; then :
24815   withval=$with_boot_jdk_jvmargs;
24816 fi
24817 
24818 
24819   { $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command " >&5
24820 $as_echo_n "checking flags for boot jdk java command ... " >&6; }
24821 
24822   # Disable special log output when a debug build is used as Boot JDK...
24823 
24824   $ECHO "Check if jvm arg is ok: -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput" >&5
24825   $ECHO "Command: $JAVA -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput -version" >&5
24826   OUTPUT=`$JAVA -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput -version 2>&1`
24827   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
24828   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
24829   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
24830     boot_jdk_jvmargs="$boot_jdk_jvmargs -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput"
24831     JVM_ARG_OK=true
24832   else
24833     $ECHO "Arg failed:" >&5
24834     $ECHO "$OUTPUT" >&5
24835     JVM_ARG_OK=false
24836   fi
24837 
24838 
24839   # Apply user provided options.
24840 
24841   $ECHO "Check if jvm arg is ok: $with_boot_jdk_jvmargs" >&5
24842   $ECHO "Command: $JAVA $with_boot_jdk_jvmargs -version" >&5
24843