1 #!/bin/bash
   2 #
   3 # ##########################################################
   4 # ### THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT. ###
   5 # ##########################################################
   6 #
   7 #! /bin/sh
   8 # Guess values for system-dependent variables and create Makefiles.
   9 # Generated by GNU Autoconf 2.69 for OpenJDK jdk9.
  10 #
  11 # Report bugs to <build-dev@openjdk.java.net>.
  12 #
  13 #
  14 # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
  15 #
  16 #
  17 # This configure script is free software; the Free Software Foundation
  18 # gives unlimited permission to copy, distribute and modify it.
  19 ## -------------------- ##
  20 ## M4sh Initialization. ##
  21 ## -------------------- ##
  22 
  23 # Be more Bourne compatible
  24 DUALCASE=1; export DUALCASE # for MKS sh
  25 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
  26   emulate sh
  27   NULLCMD=:
  28   # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  29   # is contrary to our usage.  Disable this feature.
  30   alias -g '${1+"$@"}'='"$@"'
  31   setopt NO_GLOB_SUBST
  32 else
  33   case `(set -o) 2>/dev/null` in #(
  34   *posix*) :
  35     set -o posix ;; #(
  36   *) :
  37      ;;
  38 esac
  39 fi
  40 
  41 
  42 as_nl='
  43 '
  44 export as_nl
  45 # Printing a long string crashes Solaris 7 /usr/bin/printf.
  46 as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
  47 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
  48 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
  49 # Prefer a ksh shell builtin over an external printf program on Solaris,
  50 # but without wasting forks for bash or zsh.
  51 if test -z "$BASH_VERSION$ZSH_VERSION" \
  52     && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
  53   as_echo='print -r --'
  54   as_echo_n='print -rn --'
  55 elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  56   as_echo='printf %s\n'
  57   as_echo_n='printf %s'
  58 else
  59   if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
  60     as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
  61     as_echo_n='/usr/ucb/echo -n'
  62   else
  63     as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
  64     as_echo_n_body='eval
  65       arg=$1;
  66       case $arg in #(
  67       *"$as_nl"*)
  68         expr "X$arg" : "X\\(.*\\)$as_nl";
  69         arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
  70       esac;
  71       expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
  72     '
  73     export as_echo_n_body
  74     as_echo_n='sh -c $as_echo_n_body as_echo'
  75   fi
  76   export as_echo_body
  77   as_echo='sh -c $as_echo_body as_echo'
  78 fi
  79 
  80 # The user is always right.
  81 if test "${PATH_SEPARATOR+set}" != set; then
  82   PATH_SEPARATOR=:
  83   (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
  84     (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
  85       PATH_SEPARATOR=';'
  86   }
  87 fi
  88 
  89 
  90 # IFS
  91 # We need space, tab and new line, in precisely that order.  Quoting is
  92 # there to prevent editors from complaining about space-tab.
  93 # (If _AS_PATH_WALK were called with IFS unset, it would disable word
  94 # splitting by setting IFS to empty value.)
  95 IFS=" ""        $as_nl"
  96 
  97 # Find who we are.  Look in the path if we contain no directory separator.
  98 as_myself=
  99 case $0 in #((
 100   *[\\/]* ) as_myself=$0 ;;
 101   *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 102 for as_dir in $PATH
 103 do
 104   IFS=$as_save_IFS
 105   test -z "$as_dir" && as_dir=.
 106     test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 107   done
 108 IFS=$as_save_IFS
 109 
 110      ;;
 111 esac
 112 # We did not find ourselves, most probably we were run as `sh COMMAND'
 113 # in which case we are not to be found in the path.
 114 if test "x$as_myself" = x; then
 115   as_myself=$0
 116 fi
 117 if test ! -f "$as_myself"; then
 118   $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
 119   exit 1
 120 fi
 121 
 122 # Unset variables that we do not need and which cause bugs (e.g. in
 123 # pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
 124 # suppresses any "Segmentation fault" message there.  '((' could
 125 # trigger a bug in pdksh 5.2.14.
 126 for as_var in BASH_ENV ENV MAIL MAILPATH
 127 do eval test x\${$as_var+set} = xset \
 128   && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
 129 done
 130 PS1='$ '
 131 PS2='> '
 132 PS4='+ '
 133 
 134 # NLS nuisances.
 135 LC_ALL=C
 136 export LC_ALL
 137 LANGUAGE=C
 138 export LANGUAGE
 139 
 140 # CDPATH.
 141 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
 142 
 143 # Use a proper internal environment variable to ensure we don't fall
 144   # into an infinite loop, continuously re-executing ourselves.
 145   if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
 146     _as_can_reexec=no; export _as_can_reexec;
 147     # We cannot yet assume a decent shell, so we have to provide a
 148 # neutralization value for shells without unset; and this also
 149 # works around shells that cannot unset nonexistent variables.
 150 # Preserve -v and -x to the replacement shell.
 151 BASH_ENV=/dev/null
 152 ENV=/dev/null
 153 (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
 154 case $- in # ((((
 155   *v*x* | *x*v* ) as_opts=-vx ;;
 156   *v* ) as_opts=-v ;;
 157   *x* ) as_opts=-x ;;
 158   * ) as_opts= ;;
 159 esac
 160 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
 161 # Admittedly, this is quite paranoid, since all the known shells bail
 162 # out after a failed `exec'.
 163 $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
 164 as_fn_exit 255
 165   fi
 166   # We don't want this to propagate to other subprocesses.
 167           { _as_can_reexec=; unset _as_can_reexec;}
 168 if test "x$CONFIG_SHELL" = x; then
 169   as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
 170   emulate sh
 171   NULLCMD=:
 172   # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
 173   # is contrary to our usage.  Disable this feature.
 174   alias -g '\${1+\"\$@\"}'='\"\$@\"'
 175   setopt NO_GLOB_SUBST
 176 else
 177   case \`(set -o) 2>/dev/null\` in #(
 178   *posix*) :
 179     set -o posix ;; #(
 180   *) :
 181      ;;
 182 esac
 183 fi
 184 "
 185   as_required="as_fn_return () { (exit \$1); }
 186 as_fn_success () { as_fn_return 0; }
 187 as_fn_failure () { as_fn_return 1; }
 188 as_fn_ret_success () { return 0; }
 189 as_fn_ret_failure () { return 1; }
 190 
 191 exitcode=0
 192 as_fn_success || { exitcode=1; echo as_fn_success failed.; }
 193 as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
 194 as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
 195 as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
 196 if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
 197 
 198 else
 199   exitcode=1; echo positional parameters were not saved.
 200 fi
 201 test x\$exitcode = x0 || exit 1
 202 test -x / || exit 1"
 203   as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
 204   as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
 205   eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
 206   test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
 207 test \$(( 1 + 1 )) = 2 || exit 1"
 208   if (eval "$as_required") 2>/dev/null; then :
 209   as_have_required=yes
 210 else
 211   as_have_required=no
 212 fi
 213   if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
 214 
 215 else
 216   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 217 as_found=false
 218 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 219 do
 220   IFS=$as_save_IFS
 221   test -z "$as_dir" && as_dir=.
 222   as_found=:
 223   case $as_dir in #(
 224          /*)
 225            for as_base in sh bash ksh sh5; do
 226              # Try only shells that exist, to save several forks.
 227              as_shell=$as_dir/$as_base
 228              if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
 229                     { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
 230   CONFIG_SHELL=$as_shell as_have_required=yes
 231                    if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
 232   break 2
 233 fi
 234 fi
 235            done;;
 236        esac
 237   as_found=false
 238 done
 239 $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
 240               { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
 241   CONFIG_SHELL=$SHELL as_have_required=yes
 242 fi; }
 243 IFS=$as_save_IFS
 244 
 245 
 246       if test "x$CONFIG_SHELL" != x; then :
 247   export CONFIG_SHELL
 248              # We cannot yet assume a decent shell, so we have to provide a
 249 # neutralization value for shells without unset; and this also
 250 # works around shells that cannot unset nonexistent variables.
 251 # Preserve -v and -x to the replacement shell.
 252 BASH_ENV=/dev/null
 253 ENV=/dev/null
 254 (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
 255 case $- in # ((((
 256   *v*x* | *x*v* ) as_opts=-vx ;;
 257   *v* ) as_opts=-v ;;
 258   *x* ) as_opts=-x ;;
 259   * ) as_opts= ;;
 260 esac
 261 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
 262 # Admittedly, this is quite paranoid, since all the known shells bail
 263 # out after a failed `exec'.
 264 $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
 265 exit 255
 266 fi
 267 
 268     if test x$as_have_required = xno; then :
 269   $as_echo "$0: This script requires a shell more modern than all"
 270   $as_echo "$0: the shells that I found on your system."
 271   if test x${ZSH_VERSION+set} = xset ; then
 272     $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
 273     $as_echo "$0: be upgraded to zsh 4.3.4 or later."
 274   else
 275     $as_echo "$0: Please tell bug-autoconf@gnu.org and
 276 $0: build-dev@openjdk.java.net about your system, including
 277 $0: any error possibly output before this message. Then
 278 $0: install a modern shell, or manually run the script
 279 $0: under such a shell if you do have one."
 280   fi
 281   exit 1
 282 fi
 283 fi
 284 fi
 285 SHELL=${CONFIG_SHELL-/bin/sh}
 286 export SHELL
 287 # Unset more variables known to interfere with behavior of common tools.
 288 CLICOLOR_FORCE= GREP_OPTIONS=
 289 unset CLICOLOR_FORCE GREP_OPTIONS
 290 
 291 ## --------------------- ##
 292 ## M4sh Shell Functions. ##
 293 ## --------------------- ##
 294 # as_fn_unset VAR
 295 # ---------------
 296 # Portably unset VAR.
 297 as_fn_unset ()
 298 {
 299   { eval $1=; unset $1;}
 300 }
 301 as_unset=as_fn_unset
 302 
 303 # as_fn_set_status STATUS
 304 # -----------------------
 305 # Set $? to STATUS, without forking.
 306 as_fn_set_status ()
 307 {
 308   return $1
 309 } # as_fn_set_status
 310 
 311 # as_fn_exit STATUS
 312 # -----------------
 313 # Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
 314 as_fn_exit ()
 315 {
 316   set +e
 317   as_fn_set_status $1
 318   exit $1
 319 } # as_fn_exit
 320 
 321 # as_fn_mkdir_p
 322 # -------------
 323 # Create "$as_dir" as a directory, including parents if necessary.
 324 as_fn_mkdir_p ()
 325 {
 326 
 327   case $as_dir in #(
 328   -*) as_dir=./$as_dir;;
 329   esac
 330   test -d "$as_dir" || eval $as_mkdir_p || {
 331     as_dirs=
 332     while :; do
 333       case $as_dir in #(
 334       *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
 335       *) as_qdir=$as_dir;;
 336       esac
 337       as_dirs="'$as_qdir' $as_dirs"
 338       as_dir=`$as_dirname -- "$as_dir" ||
 339 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 340          X"$as_dir" : 'X\(//\)[^/]' \| \
 341          X"$as_dir" : 'X\(//\)$' \| \
 342          X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
 343 $as_echo X"$as_dir" |
 344     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
 345             s//\1/
 346             q
 347           }
 348           /^X\(\/\/\)[^/].*/{
 349             s//\1/
 350             q
 351           }
 352           /^X\(\/\/\)$/{
 353             s//\1/
 354             q
 355           }
 356           /^X\(\/\).*/{
 357             s//\1/
 358             q
 359           }
 360           s/.*/./; q'`
 361       test -d "$as_dir" && break
 362     done
 363     test -z "$as_dirs" || eval "mkdir $as_dirs"
 364   } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
 365 
 366 
 367 } # as_fn_mkdir_p
 368 
 369 # as_fn_executable_p FILE
 370 # -----------------------
 371 # Test if FILE is an executable regular file.
 372 as_fn_executable_p ()
 373 {
 374   test -f "$1" && test -x "$1"
 375 } # as_fn_executable_p
 376 # as_fn_append VAR VALUE
 377 # ----------------------
 378 # Append the text in VALUE to the end of the definition contained in VAR. Take
 379 # advantage of any shell optimizations that allow amortized linear growth over
 380 # repeated appends, instead of the typical quadratic growth present in naive
 381 # implementations.
 382 if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
 383   eval 'as_fn_append ()
 384   {
 385     eval $1+=\$2
 386   }'
 387 else
 388   as_fn_append ()
 389   {
 390     eval $1=\$$1\$2
 391   }
 392 fi # as_fn_append
 393 
 394 # as_fn_arith ARG...
 395 # ------------------
 396 # Perform arithmetic evaluation on the ARGs, and store the result in the
 397 # global $as_val. Take advantage of shells that can avoid forks. The arguments
 398 # must be portable across $(()) and expr.
 399 if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
 400   eval 'as_fn_arith ()
 401   {
 402     as_val=$(( $* ))
 403   }'
 404 else
 405   as_fn_arith ()
 406   {
 407     as_val=`expr "$@" || test $? -eq 1`
 408   }
 409 fi # as_fn_arith
 410 
 411 
 412 # as_fn_error STATUS ERROR [LINENO LOG_FD]
 413 # ----------------------------------------
 414 # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
 415 # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
 416 # script with STATUS, using 1 if that was 0.
 417 as_fn_error ()
 418 {
 419   as_status=$1; test $as_status -eq 0 && as_status=1
 420   if test "$4"; then
 421     as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
 422     $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
 423   fi
 424   $as_echo "$as_me: error: $2" >&2
 425   as_fn_exit $as_status
 426 } # as_fn_error
 427 
 428 if expr a : '\(a\)' >/dev/null 2>&1 &&
 429    test "X`expr 00001 : '.*\(...\)'`" = X001; then
 430   as_expr=expr
 431 else
 432   as_expr=false
 433 fi
 434 
 435 if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
 436   as_basename=basename
 437 else
 438   as_basename=false
 439 fi
 440 
 441 if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
 442   as_dirname=dirname
 443 else
 444   as_dirname=false
 445 fi
 446 
 447 as_me=`$as_basename -- "$0" ||
 448 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
 449          X"$0" : 'X\(//\)$' \| \
 450          X"$0" : 'X\(/\)' \| . 2>/dev/null ||
 451 $as_echo X/"$0" |
 452     sed '/^.*\/\([^/][^/]*\)\/*$/{
 453             s//\1/
 454             q
 455           }
 456           /^X\/\(\/\/\)$/{
 457             s//\1/
 458             q
 459           }
 460           /^X\/\(\/\).*/{
 461             s//\1/
 462             q
 463           }
 464           s/.*/./; q'`
 465 
 466 # Avoid depending upon Character Ranges.
 467 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
 468 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 469 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
 470 as_cr_digits='0123456789'
 471 as_cr_alnum=$as_cr_Letters$as_cr_digits
 472 
 473 
 474   as_lineno_1=$LINENO as_lineno_1a=$LINENO
 475   as_lineno_2=$LINENO as_lineno_2a=$LINENO
 476   eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
 477   test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
 478   # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
 479   sed -n '
 480     p
 481     /[$]LINENO/=
 482   ' <$as_myself |
 483     sed '
 484       s/[$]LINENO.*/&-/
 485       t lineno
 486       b
 487       :lineno
 488       N
 489       :loop
 490       s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
 491       t loop
 492       s/-\n.*//
 493     ' >$as_me.lineno &&
 494   chmod +x "$as_me.lineno" ||
 495     { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
 496 
 497   # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
 498   # already done that, so ensure we don't try to do so again and fall
 499   # in an infinite loop.  This has already happened in practice.
 500   _as_can_reexec=no; export _as_can_reexec
 501   # Don't try to exec as it changes $[0], causing all sort of problems
 502   # (the dirname of $[0] is not the place where we might find the
 503   # original and so on.  Autoconf is especially sensitive to this).
 504   . "./$as_me.lineno"
 505   # Exit status is that of the last command.
 506   exit
 507 }
 508 
 509 ECHO_C= ECHO_N= ECHO_T=
 510 case `echo -n x` in #(((((
 511 -n*)
 512   case `echo 'xy\c'` in
 513   *c*) ECHO_T=' ';;     # ECHO_T is single tab character.
 514   xy)  ECHO_C='\c';;
 515   *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
 516        ECHO_T=' ';;
 517   esac;;
 518 *)
 519   ECHO_N='-n';;
 520 esac
 521 
 522 rm -f conf$$ conf$$.exe conf$$.file
 523 if test -d conf$$.dir; then
 524   rm -f conf$$.dir/conf$$.file
 525 else
 526   rm -f conf$$.dir
 527   mkdir conf$$.dir 2>/dev/null
 528 fi
 529 if (echo >conf$$.file) 2>/dev/null; then
 530   if ln -s conf$$.file conf$$ 2>/dev/null; then
 531     as_ln_s='ln -s'
 532     # ... but there are two gotchas:
 533     # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
 534     # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
 535     # In both cases, we have to default to `cp -pR'.
 536     ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
 537       as_ln_s='cp -pR'
 538   elif ln conf$$.file conf$$ 2>/dev/null; then
 539     as_ln_s=ln
 540   else
 541     as_ln_s='cp -pR'
 542   fi
 543 else
 544   as_ln_s='cp -pR'
 545 fi
 546 rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
 547 rmdir conf$$.dir 2>/dev/null
 548 
 549 if mkdir -p . 2>/dev/null; then
 550   as_mkdir_p='mkdir -p "$as_dir"'
 551 else
 552   test -d ./-p && rmdir ./-p
 553   as_mkdir_p=false
 554 fi
 555 
 556 as_test_x='test -x'
 557 as_executable_p=as_fn_executable_p
 558 
 559 # Sed expression to map a string onto a valid CPP name.
 560 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 561 
 562 # Sed expression to map a string onto a valid variable name.
 563 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 564 
 565 
 566 test -n "$DJDIR" || exec 7<&0 </dev/null
 567 exec 6>&1
 568 
 569 # Name of the host.
 570 # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
 571 # so uname gets run too.
 572 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 573 
 574 #
 575 # Initializations.
 576 #
 577 ac_default_prefix=/usr/local
 578 ac_clean_files=
 579 ac_config_libobj_dir=.
 580 LIBOBJS=
 581 cross_compiling=no
 582 subdirs=
 583 MFLAGS=
 584 MAKEFLAGS=
 585 
 586 # Identity of this package.
 587 PACKAGE_NAME='OpenJDK'
 588 PACKAGE_TARNAME='openjdk'
 589 PACKAGE_VERSION='jdk9'
 590 PACKAGE_STRING='OpenJDK jdk9'
 591 PACKAGE_BUGREPORT='build-dev@openjdk.java.net'
 592 PACKAGE_URL='http://openjdk.java.net'
 593 
 594 # Factoring default headers for most tests.
 595 ac_includes_default="\
 596 #include <stdio.h>
 597 #ifdef HAVE_SYS_TYPES_H
 598 # include <sys/types.h>
 599 #endif
 600 #ifdef HAVE_SYS_STAT_H
 601 # include <sys/stat.h>
 602 #endif
 603 #ifdef STDC_HEADERS
 604 # include <stdlib.h>
 605 # include <stddef.h>
 606 #else
 607 # ifdef HAVE_STDLIB_H
 608 #  include <stdlib.h>
 609 # endif
 610 #endif
 611 #ifdef HAVE_STRING_H
 612 # if !defined STDC_HEADERS && defined HAVE_MEMORY_H
 613 #  include <memory.h>
 614 # endif
 615 # include <string.h>
 616 #endif
 617 #ifdef HAVE_STRINGS_H
 618 # include <strings.h>
 619 #endif
 620 #ifdef HAVE_INTTYPES_H
 621 # include <inttypes.h>
 622 #endif
 623 #ifdef HAVE_STDINT_H
 624 # include <stdint.h>
 625 #endif
 626 #ifdef HAVE_UNISTD_H
 627 # include <unistd.h>
 628 #endif"
 629 
 630 ac_subst_vars='LTLIBOBJS
 631 LIBOBJS
 632 CFLAGS_CCACHE
 633 CCACHE
 634 USE_PRECOMPILED_HEADER
 635 SJAVAC_SERVER_DIR
 636 ENABLE_SJAVAC
 637 SJAVAC_SERVER_JAVA_FLAGS
 638 SJAVAC_SERVER_JAVA
 639 JAVA_TOOL_FLAGS_SMALL
 640 JAVA_FLAGS_SMALL
 641 JAVA_FLAGS_BIG
 642 JAVA_FLAGS
 643 JOBS
 644 MEMORY_SIZE
 645 NUM_CORES
 646 ENABLE_INTREE_EC
 647 SALIB_NAME
 648 HOTSPOT_MAKE_ARGS
 649 MSVCP_DLL
 650 MSVCR_DLL
 651 LIBCXX
 652 LLVM_LIBS
 653 LLVM_LDFLAGS
 654 LLVM_CFLAGS
 655 LLVM_CONFIG
 656 LIBFFI_LIBS
 657 LIBFFI_CFLAGS
 658 STATIC_CXX_SETTING
 659 LIBDL
 660 LIBM
 661 LIBZIP_CAN_USE_MMAP
 662 USE_EXTERNAL_LIBZ
 663 USE_EXTERNAL_LIBPNG
 664 PNG_LIBS
 665 PNG_CFLAGS
 666 USE_EXTERNAL_LCMS
 667 LCMS_LIBS
 668 LCMS_CFLAGS
 669 USE_EXTERNAL_LIBGIF
 670 USE_EXTERNAL_LIBJPEG
 671 ALSA_LIBS
 672 ALSA_CFLAGS
 673 FREETYPE_BUNDLE_LIB_PATH
 674 FREETYPE_LIBS
 675 FREETYPE_CFLAGS
 676 CUPS_CFLAGS
 677 X_EXTRA_LIBS
 678 X_LIBS
 679 X_PRE_LIBS
 680 X_CFLAGS
 681 XMKMF
 682 FIXPATH
 683 ZIP_DEBUGINFO_FILES
 684 ENABLE_DEBUG_SYMBOLS
 685 CFLAGS_WARNINGS_ARE_ERRORS
 686 COMPILER_SUPPORTS_TARGET_BITS_FLAG
 687 ZERO_ARCHFLAG
 688 LDFLAGS_CXX_JDK
 689 LDFLAGS_JDKEXE_SUFFIX
 690 LDFLAGS_JDKLIB_SUFFIX
 691 LDFLAGS_JDKEXE
 692 LDFLAGS_JDKLIB
 693 CXXFLAGS_JDKEXE
 694 CXXFLAGS_JDKLIB
 695 CFLAGS_JDKEXE
 696 CFLAGS_JDKLIB
 697 MACOSX_VERSION_MIN
 698 LEGACY_EXTRA_LDFLAGS
 699 LEGACY_EXTRA_CXXFLAGS
 700 LEGACY_EXTRA_CFLAGS
 701 CXX_O_FLAG_NONE
 702 CXX_O_FLAG_DEBUG
 703 CXX_O_FLAG_NORM
 704 CXX_O_FLAG_HI
 705 CXX_O_FLAG_HIGHEST
 706 C_O_FLAG_NONE
 707 C_O_FLAG_DEBUG
 708 C_O_FLAG_NORM
 709 C_O_FLAG_HI
 710 C_O_FLAG_HIGHEST
 711 CXXFLAGS_DEBUG_OPTIONS
 712 CFLAGS_DEBUG_OPTIONS
 713 CXXFLAGS_DEBUG_SYMBOLS
 714 CFLAGS_DEBUG_SYMBOLS
 715 CXX_FLAG_DEPS
 716 C_FLAG_DEPS
 717 SET_SHARED_LIBRARY_MAPFILE
 718 SET_SHARED_LIBRARY_NAME
 719 SET_SHARED_LIBRARY_ORIGIN
 720 SET_EXECUTABLE_ORIGIN
 721 SHARED_LIBRARY_FLAGS
 722 CXX_FLAG_REORDER
 723 C_FLAG_REORDER
 724 SYSROOT_LDFLAGS
 725 SYSROOT_CFLAGS
 726 RC_FLAGS
 727 AR_OUT_OPTION
 728 LD_OUT_OPTION
 729 EXE_OUT_OPTION
 730 CC_OUT_OPTION
 731 POST_MCS_CMD
 732 POST_STRIP_CMD
 733 ARFLAGS
 734 COMPILER_TARGET_BITS_FLAG
 735 JT_HOME
 736 JTREGEXE
 737 USING_BROKEN_SUSE_LD
 738 PACKAGE_PATH
 739 LDEXECXX
 740 LDEXE
 741 USE_CLANG
 742 HOTSPOT_LD
 743 HOTSPOT_CXX
 744 HOTSPOT_RC
 745 HOTSPOT_MT
 746 BUILD_LD
 747 BUILD_CXX
 748 BUILD_CC
 749 ac_ct_OBJDUMP
 750 OBJDUMP
 751 ac_ct_OBJCOPY
 752 OBJCOPY
 753 ac_ct_NM
 754 ac_ct_STRIP
 755 MCS
 756 GNM
 757 NM
 758 STRIP
 759 MSBUILD
 760 DUMPBIN
 761 RC
 762 MT
 763 LIPO
 764 ac_ct_AR
 765 AR
 766 AS
 767 LDCXX
 768 LD
 769 CXXCPP
 770 CPP
 771 ac_ct_CXX
 772 CXXFLAGS
 773 CXX
 774 ac_ct_PROPER_COMPILER_CXX
 775 PROPER_COMPILER_CXX
 776 TOOLCHAIN_PATH_CXX
 777 POTENTIAL_CXX
 778 OBJEXT
 779 EXEEXT
 780 ac_ct_CC
 781 CPPFLAGS
 782 LDFLAGS
 783 CFLAGS
 784 CC
 785 ac_ct_PROPER_COMPILER_CC
 786 PROPER_COMPILER_CC
 787 TOOLCHAIN_PATH_CC
 788 POTENTIAL_CC
 789 VS_LIB
 790 VS_INCLUDE
 791 VS_PATH
 792 CYGWIN_LINK
 793 EXE_SUFFIX
 794 OBJ_SUFFIX
 795 STATIC_LIBRARY
 796 SHARED_LIBRARY
 797 STATIC_LIBRARY_SUFFIX
 798 SHARED_LIBRARY_SUFFIX
 799 LIBRARY_PREFIX
 800 TOOLCHAIN_TYPE
 801 BUILD_HOTSPOT
 802 HOTSPOT_DIST
 803 BUILD_OUTPUT
 804 OVERRIDE_SRC_ROOT
 805 ADD_SRC_ROOT
 806 JDK_TOPDIR
 807 NASHORN_TOPDIR
 808 HOTSPOT_TOPDIR
 809 JAXWS_TOPDIR
 810 JAXP_TOPDIR
 811 CORBA_TOPDIR
 812 LANGTOOLS_TOPDIR
 813 JAVAC_FLAGS
 814 BOOT_JDK_SOURCETARGET
 815 JARSIGNER
 816 NATIVE2ASCII
 817 JAR
 818 JAVAH
 819 JAVAC
 820 JAVA
 821 BOOT_JDK
 822 JAVA_CHECK
 823 JAVAC_CHECK
 824 COOKED_BUILD_NUMBER
 825 JDK_VERSION
 826 COPYRIGHT_YEAR
 827 MACOSX_BUNDLE_ID_BASE
 828 MACOSX_BUNDLE_NAME_BASE
 829 COMPANY_NAME
 830 JDK_RC_PLATFORM_NAME
 831 PRODUCT_SUFFIX
 832 PRODUCT_NAME
 833 LAUNCHER_NAME
 834 MILESTONE
 835 JDK_BUILD_NUMBER
 836 JDK_UPDATE_VERSION
 837 JDK_MICRO_VERSION
 838 JDK_MINOR_VERSION
 839 JDK_MAJOR_VERSION
 840 USER_RELEASE_SUFFIX
 841 COMPRESS_JARS
 842 RMICONNECTOR_IIOP
 843 UNLIMITED_CRYPTO
 844 CACERTS_FILE
 845 TEST_IN_BUILD
 846 BUILD_HEADLESS
 847 SUPPORT_HEADFUL
 848 SUPPORT_HEADLESS
 849 BDEPS_FTP
 850 BDEPS_UNZIP
 851 OS_VERSION_MICRO
 852 OS_VERSION_MINOR
 853 OS_VERSION_MAJOR
 854 PKG_CONFIG
 855 BASH_ARGS
 856 CODESIGN
 857 XATTR
 858 DSYMUTIL
 859 IS_GNU_TIME
 860 TIME
 861 STAT
 862 HG
 863 READELF
 864 OTOOL
 865 LDD
 866 ZIP
 867 UNZIP
 868 FIND_DELETE
 869 OUTPUT_SYNC
 870 OUTPUT_SYNC_SUPPORTED
 871 MAKE
 872 CHECK_TOOLSDIR_MAKE
 873 CHECK_TOOLSDIR_GMAKE
 874 CHECK_MAKE
 875 CHECK_GMAKE
 876 PKGHANDLER
 877 OUTPUT_ROOT
 878 CONF_NAME
 879 SPEC
 880 SDKROOT
 881 XCODEBUILD
 882 BUILD_VARIANT_RELEASE
 883 DEBUG_CLASSFILES
 884 FASTDEBUG
 885 VARIANT
 886 DEBUG_LEVEL
 887 MACOSX_UNIVERSAL
 888 INCLUDE_SA
 889 JVM_VARIANT_CORE
 890 JVM_VARIANT_ZEROSHARK
 891 JVM_VARIANT_ZERO
 892 JVM_VARIANT_KERNEL
 893 JVM_VARIANT_MINIMAL1
 894 JVM_VARIANT_CLIENT
 895 JVM_VARIANT_SERVER
 896 JVM_VARIANTS
 897 JVM_INTERPRETER
 898 JDK_VARIANT
 899 SET_OPENJDK
 900 BUILD_LOG_WRAPPER
 901 BUILD_LOG_PREVIOUS
 902 BUILD_LOG
 903 TOPDIR
 904 PATH_SEP
 905 ZERO_ARCHDEF
 906 DEFINE_CROSS_COMPILE_ARCH
 907 LP64
 908 OPENJDK_TARGET_OS_EXPORT_DIR
 909 OPENJDK_TARGET_CPU_JLI_CFLAGS
 910 OPENJDK_TARGET_CPU_OSARCH
 911 OPENJDK_TARGET_CPU_ISADIR
 912 OPENJDK_TARGET_CPU_LIBDIR
 913 OPENJDK_TARGET_CPU_LEGACY_LIB
 914 OPENJDK_TARGET_CPU_LEGACY
 915 REQUIRED_OS_VERSION
 916 REQUIRED_OS_NAME
 917 COMPILE_TYPE
 918 OPENJDK_TARGET_CPU_ENDIAN
 919 OPENJDK_TARGET_CPU_BITS
 920 OPENJDK_TARGET_CPU_ARCH
 921 OPENJDK_TARGET_CPU
 922 OPENJDK_TARGET_OS_ENV
 923 OPENJDK_TARGET_OS_TYPE
 924 OPENJDK_TARGET_OS
 925 OPENJDK_BUILD_CPU_ENDIAN
 926 OPENJDK_BUILD_CPU_BITS
 927 OPENJDK_BUILD_CPU_ARCH
 928 OPENJDK_BUILD_CPU
 929 OPENJDK_BUILD_OS_ENV
 930 OPENJDK_BUILD_OS_TYPE
 931 OPENJDK_BUILD_OS
 932 OPENJDK_BUILD_AUTOCONF_NAME
 933 OPENJDK_TARGET_AUTOCONF_NAME
 934 target_os
 935 target_vendor
 936 target_cpu
 937 target
 938 host_os
 939 host_vendor
 940 host_cpu
 941 host
 942 build_os
 943 build_vendor
 944 build_cpu
 945 build
 946 CPIO
 947 SETFILE
 948 DF
 949 READLINK
 950 CYGPATH
 951 SED
 952 FGREP
 953 EGREP
 954 GREP
 955 AWK
 956 XARGS
 957 WHICH
 958 WC
 959 UNIQ
 960 UNAME
 961 TR
 962 TOUCH
 963 TEE
 964 TAR
 965 TAIL
 966 SORT
 967 SH
 968 RM
 969 PRINTF
 970 NAWK
 971 MV
 972 MKTEMP
 973 MKDIR
 974 LS
 975 LN
 976 HEAD
 977 FIND
 978 FILE
 979 EXPR
 980 ECHO
 981 DIRNAME
 982 DIFF
 983 DATE
 984 CUT
 985 CP
 986 COMM
 987 CMP
 988 CHMOD
 989 CAT
 990 BASH
 991 BASENAME
 992 DATE_WHEN_CONFIGURED
 993 ORIGINAL_PATH
 994 CONFIGURE_COMMAND_LINE
 995 target_alias
 996 host_alias
 997 build_alias
 998 LIBS
 999 ECHO_T
1000 ECHO_N
1001 ECHO_C
1002 DEFS
1003 mandir
1004 localedir
1005 libdir
1006 psdir
1007 pdfdir
1008 dvidir
1009 htmldir
1010 infodir
1011 docdir
1012 oldincludedir
1013 includedir
1014 localstatedir
1015 sharedstatedir
1016 sysconfdir
1017 datadir
1018 datarootdir
1019 libexecdir
1020 sbindir
1021 bindir
1022 program_transform_name
1023 prefix
1024 exec_prefix
1025 PACKAGE_URL
1026 PACKAGE_BUGREPORT
1027 PACKAGE_STRING
1028 PACKAGE_VERSION
1029 PACKAGE_TARNAME
1030 PACKAGE_NAME
1031 PATH_SEPARATOR
1032 SHELL'
1033 ac_subst_files=''
1034 ac_user_opts='
1035 enable_option_checking
1036 with_target_bits
1037 enable_openjdk_only
1038 with_custom_make_dir
1039 with_jdk_variant
1040 with_jvm_interpreter
1041 with_jvm_variants
1042 enable_debug
1043 with_debug_level
1044 with_devkit
1045 with_sys_root
1046 with_sysroot
1047 with_tools_dir
1048 with_toolchain_path
1049 with_extra_path
1050 with_sdk_name
1051 with_conf_name
1052 with_output_sync
1053 with_builddeps_conf
1054 with_builddeps_server
1055 with_builddeps_dir
1056 with_builddeps_group
1057 enable_headful
1058 enable_hotspot_test_in_build
1059 with_cacerts_file
1060 enable_unlimited_crypto
1061 enable_rmiconnector_iiop
1062 with_milestone
1063 with_update_version
1064 with_user_release_suffix
1065 with_build_number
1066 with_copyright_year
1067 with_boot_jdk
1068 with_add_source_root
1069 with_override_source_root
1070 with_adds_and_overrides
1071 with_override_langtools
1072 with_override_corba
1073 with_override_jaxp
1074 with_override_jaxws
1075 with_override_hotspot
1076 with_override_nashorn
1077 with_override_jdk
1078 with_import_hotspot
1079 with_toolchain_type
1080 with_toolchain_version
1081 with_jtreg
1082 with_extra_cflags
1083 with_extra_cxxflags
1084 with_extra_ldflags
1085 enable_debug_symbols
1086 enable_zip_debug_info
1087 with_x
1088 with_cups
1089 with_cups_include
1090 with_freetype
1091 with_freetype_include
1092 with_freetype_lib
1093 with_freetype_src
1094 enable_freetype_bundling
1095 with_alsa
1096 with_alsa_include
1097 with_alsa_lib
1098 with_libjpeg
1099 with_giflib
1100 with_lcms
1101 with_libpng
1102 with_zlib
1103 with_stdc__lib
1104 with_msvcr_dll
1105 with_msvcp_dll
1106 with_dxsdk
1107 with_dxsdk_lib
1108 with_dxsdk_include
1109 with_num_cores
1110 with_memory_size
1111 with_jobs
1112 with_boot_jdk_jvmargs
1113 with_sjavac_server_java
1114 enable_sjavac
1115 enable_precompiled_headers
1116 enable_ccache
1117 with_ccache_dir
1118 '
1119       ac_precious_vars='build_alias
1120 host_alias
1121 target_alias
1122 BASENAME
1123 BASH
1124 CAT
1125 CHMOD
1126 CMP
1127 COMM
1128 CP
1129 CUT
1130 DATE
1131 DIFF
1132 DIRNAME
1133 ECHO
1134 EXPR
1135 FILE
1136 FIND
1137 HEAD
1138 LN
1139 LS
1140 MKDIR
1141 MKTEMP
1142 MV
1143 NAWK
1144 PRINTF
1145 RM
1146 SH
1147 SORT
1148 TAIL
1149 TAR
1150 TEE
1151 TOUCH
1152 TR
1153 UNAME
1154 UNIQ
1155 WC
1156 WHICH
1157 XARGS
1158 AWK
1159 GREP
1160 EGREP
1161 FGREP
1162 SED
1163 CYGPATH
1164 READLINK
1165 DF
1166 SETFILE
1167 CPIO
1168 UNZIP
1169 ZIP
1170 LDD
1171 OTOOL
1172 READELF
1173 HG
1174 STAT
1175 TIME
1176 DSYMUTIL
1177 XATTR
1178 CODESIGN
1179 PKG_CONFIG
1180 JAVA
1181 JAVAC
1182 JAVAH
1183 JAR
1184 NATIVE2ASCII
1185 JARSIGNER
1186 CC
1187 CFLAGS
1188 LDFLAGS
1189 LIBS
1190 CPPFLAGS
1191 CXX
1192 CXXFLAGS
1193 CCC
1194 CPP
1195 CXXCPP
1196 AS
1197 AR
1198 LIPO
1199 STRIP
1200 NM
1201 GNM
1202 MCS
1203 OBJCOPY
1204 OBJDUMP
1205 BUILD_CC
1206 BUILD_CXX
1207 BUILD_LD
1208 JTREGEXE
1209 XMKMF
1210 FREETYPE_CFLAGS
1211 FREETYPE_LIBS
1212 ALSA_CFLAGS
1213 ALSA_LIBS
1214 LCMS_CFLAGS
1215 LCMS_LIBS
1216 PNG_CFLAGS
1217 PNG_LIBS
1218 LIBFFI_CFLAGS
1219 LIBFFI_LIBS
1220 CCACHE'
1221 
1222 
1223 # Initialize some variables set by options.
1224 ac_init_help=
1225 ac_init_version=false
1226 ac_unrecognized_opts=
1227 ac_unrecognized_sep=
1228 # The variables have the same names as the options, with
1229 # dashes changed to underlines.
1230 cache_file=/dev/null
1231 exec_prefix=NONE
1232 no_create=
1233 no_recursion=
1234 prefix=NONE
1235 program_prefix=NONE
1236 program_suffix=NONE
1237 program_transform_name=s,x,x,
1238 silent=
1239 site=
1240 srcdir=
1241 verbose=
1242 x_includes=NONE
1243 x_libraries=NONE
1244 
1245 # Installation directory options.
1246 # These are left unexpanded so users can "make install exec_prefix=/foo"
1247 # and all the variables that are supposed to be based on exec_prefix
1248 # by default will actually change.
1249 # Use braces instead of parens because sh, perl, etc. also accept them.
1250 # (The list follows the same order as the GNU Coding Standards.)
1251 bindir='${exec_prefix}/bin'
1252 sbindir='${exec_prefix}/sbin'
1253 libexecdir='${exec_prefix}/libexec'
1254 datarootdir='${prefix}/share'
1255 datadir='${datarootdir}'
1256 sysconfdir='${prefix}/etc'
1257 sharedstatedir='${prefix}/com'
1258 localstatedir='${prefix}/var'
1259 includedir='${prefix}/include'
1260 oldincludedir='/usr/include'
1261 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
1262 infodir='${datarootdir}/info'
1263 htmldir='${docdir}'
1264 dvidir='${docdir}'
1265 pdfdir='${docdir}'
1266 psdir='${docdir}'
1267 libdir='${exec_prefix}/lib'
1268 localedir='${datarootdir}/locale'
1269 mandir='${datarootdir}/man'
1270 
1271 ac_prev=
1272 ac_dashdash=
1273 for ac_option
1274 do
1275   # If the previous option needs an argument, assign it.
1276   if test -n "$ac_prev"; then
1277     eval $ac_prev=\$ac_option
1278     ac_prev=
1279     continue
1280   fi
1281 
1282   case $ac_option in
1283   *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
1284   *=)   ac_optarg= ;;
1285   *)    ac_optarg=yes ;;
1286   esac
1287 
1288   # Accept the important Cygnus configure options, so we can diagnose typos.
1289 
1290   case $ac_dashdash$ac_option in
1291   --)
1292     ac_dashdash=yes ;;
1293 
1294   -bindir | --bindir | --bindi | --bind | --bin | --bi)
1295     ac_prev=bindir ;;
1296   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
1297     bindir=$ac_optarg ;;
1298 
1299   -build | --build | --buil | --bui | --bu)
1300     ac_prev=build_alias ;;
1301   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
1302     build_alias=$ac_optarg ;;
1303 
1304   -cache-file | --cache-file | --cache-fil | --cache-fi \
1305   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
1306     ac_prev=cache_file ;;
1307   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
1308   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
1309     cache_file=$ac_optarg ;;
1310 
1311   --config-cache | -C)
1312     cache_file=config.cache ;;
1313 
1314   -datadir | --datadir | --datadi | --datad)
1315     ac_prev=datadir ;;
1316   -datadir=* | --datadir=* | --datadi=* | --datad=*)
1317     datadir=$ac_optarg ;;
1318 
1319   -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
1320   | --dataroo | --dataro | --datar)
1321     ac_prev=datarootdir ;;
1322   -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
1323   | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
1324     datarootdir=$ac_optarg ;;
1325 
1326   -disable-* | --disable-*)
1327     ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
1328     # Reject names that are not valid shell variable names.
1329     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1330       as_fn_error $? "invalid feature name: $ac_useropt"
1331     ac_useropt_orig=$ac_useropt
1332     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1333     case $ac_user_opts in
1334       *"
1335 "enable_$ac_useropt"
1336 "*) ;;
1337       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
1338          ac_unrecognized_sep=', ';;
1339     esac
1340     eval enable_$ac_useropt=no ;;
1341 
1342   -docdir | --docdir | --docdi | --doc | --do)
1343     ac_prev=docdir ;;
1344   -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
1345     docdir=$ac_optarg ;;
1346 
1347   -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
1348     ac_prev=dvidir ;;
1349   -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
1350     dvidir=$ac_optarg ;;
1351 
1352   -enable-* | --enable-*)
1353     ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
1354     # Reject names that are not valid shell variable names.
1355     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1356       as_fn_error $? "invalid feature name: $ac_useropt"
1357     ac_useropt_orig=$ac_useropt
1358     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1359     case $ac_user_opts in
1360       *"
1361 "enable_$ac_useropt"
1362 "*) ;;
1363       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
1364          ac_unrecognized_sep=', ';;
1365     esac
1366     eval enable_$ac_useropt=\$ac_optarg ;;
1367 
1368   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
1369   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
1370   | --exec | --exe | --ex)
1371     ac_prev=exec_prefix ;;
1372   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
1373   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
1374   | --exec=* | --exe=* | --ex=*)
1375     exec_prefix=$ac_optarg ;;
1376 
1377   -gas | --gas | --ga | --g)
1378     # Obsolete; use --with-gas.
1379     with_gas=yes ;;
1380 
1381   -help | --help | --hel | --he | -h)
1382     ac_init_help=long ;;
1383   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
1384     ac_init_help=recursive ;;
1385   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
1386     ac_init_help=short ;;
1387 
1388   -host | --host | --hos | --ho)
1389     ac_prev=host_alias ;;
1390   -host=* | --host=* | --hos=* | --ho=*)
1391     host_alias=$ac_optarg ;;
1392 
1393   -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
1394     ac_prev=htmldir ;;
1395   -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
1396   | --ht=*)
1397     htmldir=$ac_optarg ;;
1398 
1399   -includedir | --includedir | --includedi | --included | --include \
1400   | --includ | --inclu | --incl | --inc)
1401     ac_prev=includedir ;;
1402   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
1403   | --includ=* | --inclu=* | --incl=* | --inc=*)
1404     includedir=$ac_optarg ;;
1405 
1406   -infodir | --infodir | --infodi | --infod | --info | --inf)
1407     ac_prev=infodir ;;
1408   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
1409     infodir=$ac_optarg ;;
1410 
1411   -libdir | --libdir | --libdi | --libd)
1412     ac_prev=libdir ;;
1413   -libdir=* | --libdir=* | --libdi=* | --libd=*)
1414     libdir=$ac_optarg ;;
1415 
1416   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
1417   | --libexe | --libex | --libe)
1418     ac_prev=libexecdir ;;
1419   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
1420   | --libexe=* | --libex=* | --libe=*)
1421     libexecdir=$ac_optarg ;;
1422 
1423   -localedir | --localedir | --localedi | --localed | --locale)
1424     ac_prev=localedir ;;
1425   -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
1426     localedir=$ac_optarg ;;
1427 
1428   -localstatedir | --localstatedir | --localstatedi | --localstated \
1429   | --localstate | --localstat | --localsta | --localst | --locals)
1430     ac_prev=localstatedir ;;
1431   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
1432   | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
1433     localstatedir=$ac_optarg ;;
1434 
1435   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
1436     ac_prev=mandir ;;
1437   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
1438     mandir=$ac_optarg ;;
1439 
1440   -nfp | --nfp | --nf)
1441     # Obsolete; use --without-fp.
1442     with_fp=no ;;
1443 
1444   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
1445   | --no-cr | --no-c | -n)
1446     no_create=yes ;;
1447 
1448   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
1449   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
1450     no_recursion=yes ;;
1451 
1452   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
1453   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
1454   | --oldin | --oldi | --old | --ol | --o)
1455     ac_prev=oldincludedir ;;
1456   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
1457   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
1458   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
1459     oldincludedir=$ac_optarg ;;
1460 
1461   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
1462     ac_prev=prefix ;;
1463   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
1464     prefix=$ac_optarg ;;
1465 
1466   -program-prefix | --program-prefix | --program-prefi | --program-pref \
1467   | --program-pre | --program-pr | --program-p)
1468     ac_prev=program_prefix ;;
1469   -program-prefix=* | --program-prefix=* | --program-prefi=* \
1470   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
1471     program_prefix=$ac_optarg ;;
1472 
1473   -program-suffix | --program-suffix | --program-suffi | --program-suff \
1474   | --program-suf | --program-su | --program-s)
1475     ac_prev=program_suffix ;;
1476   -program-suffix=* | --program-suffix=* | --program-suffi=* \
1477   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
1478     program_suffix=$ac_optarg ;;
1479 
1480   -program-transform-name | --program-transform-name \
1481   | --program-transform-nam | --program-transform-na \
1482   | --program-transform-n | --program-transform- \
1483   | --program-transform | --program-transfor \
1484   | --program-transfo | --program-transf \
1485   | --program-trans | --program-tran \
1486   | --progr-tra | --program-tr | --program-t)
1487     ac_prev=program_transform_name ;;
1488   -program-transform-name=* | --program-transform-name=* \
1489   | --program-transform-nam=* | --program-transform-na=* \
1490   | --program-transform-n=* | --program-transform-=* \
1491   | --program-transform=* | --program-transfor=* \
1492   | --program-transfo=* | --program-transf=* \
1493   | --program-trans=* | --program-tran=* \
1494   | --progr-tra=* | --program-tr=* | --program-t=*)
1495     program_transform_name=$ac_optarg ;;
1496 
1497   -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
1498     ac_prev=pdfdir ;;
1499   -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
1500     pdfdir=$ac_optarg ;;
1501 
1502   -psdir | --psdir | --psdi | --psd | --ps)
1503     ac_prev=psdir ;;
1504   -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
1505     psdir=$ac_optarg ;;
1506 
1507   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1508   | -silent | --silent | --silen | --sile | --sil)
1509     silent=yes ;;
1510 
1511   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
1512     ac_prev=sbindir ;;
1513   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
1514   | --sbi=* | --sb=*)
1515     sbindir=$ac_optarg ;;
1516 
1517   -sharedstatedir | --sharedstatedir | --sharedstatedi \
1518   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
1519   | --sharedst | --shareds | --shared | --share | --shar \
1520   | --sha | --sh)
1521     ac_prev=sharedstatedir ;;
1522   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
1523   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
1524   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
1525   | --sha=* | --sh=*)
1526     sharedstatedir=$ac_optarg ;;
1527 
1528   -site | --site | --sit)
1529     ac_prev=site ;;
1530   -site=* | --site=* | --sit=*)
1531     site=$ac_optarg ;;
1532 
1533   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
1534     ac_prev=srcdir ;;
1535   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
1536     srcdir=$ac_optarg ;;
1537 
1538   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
1539   | --syscon | --sysco | --sysc | --sys | --sy)
1540     ac_prev=sysconfdir ;;
1541   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
1542   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
1543     sysconfdir=$ac_optarg ;;
1544 
1545   -target | --target | --targe | --targ | --tar | --ta | --t)
1546     ac_prev=target_alias ;;
1547   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
1548     target_alias=$ac_optarg ;;
1549 
1550   -v | -verbose | --verbose | --verbos | --verbo | --verb)
1551     verbose=yes ;;
1552 
1553   -version | --version | --versio | --versi | --vers | -V)
1554     ac_init_version=: ;;
1555 
1556   -with-* | --with-*)
1557     ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1558     # Reject names that are not valid shell variable names.
1559     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1560       as_fn_error $? "invalid package name: $ac_useropt"
1561     ac_useropt_orig=$ac_useropt
1562     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1563     case $ac_user_opts in
1564       *"
1565 "with_$ac_useropt"
1566 "*) ;;
1567       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
1568          ac_unrecognized_sep=', ';;
1569     esac
1570     eval with_$ac_useropt=\$ac_optarg ;;
1571 
1572   -without-* | --without-*)
1573     ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1574     # Reject names that are not valid shell variable names.
1575     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1576       as_fn_error $? "invalid package name: $ac_useropt"
1577     ac_useropt_orig=$ac_useropt
1578     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1579     case $ac_user_opts in
1580       *"
1581 "with_$ac_useropt"
1582 "*) ;;
1583       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
1584          ac_unrecognized_sep=', ';;
1585     esac
1586     eval with_$ac_useropt=no ;;
1587 
1588   --x)
1589     # Obsolete; use --with-x.
1590     with_x=yes ;;
1591 
1592   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
1593   | --x-incl | --x-inc | --x-in | --x-i)
1594     ac_prev=x_includes ;;
1595   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
1596   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
1597     x_includes=$ac_optarg ;;
1598 
1599   -x-libraries | --x-libraries | --x-librarie | --x-librari \
1600   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
1601     ac_prev=x_libraries ;;
1602   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
1603   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1604     x_libraries=$ac_optarg ;;
1605 
1606   -*) as_fn_error $? "unrecognized option: \`$ac_option'
1607 Try \`$0 --help' for more information"
1608     ;;
1609 
1610   *=*)
1611     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1612     # Reject names that are not valid shell variable names.
1613     case $ac_envvar in #(
1614       '' | [0-9]* | *[!_$as_cr_alnum]* )
1615       as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1616     esac
1617     eval $ac_envvar=\$ac_optarg
1618     export $ac_envvar ;;
1619 
1620   *)
1621     # FIXME: should be removed in autoconf 3.0.
1622     $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1623     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1624       $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1625     : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1626     ;;
1627 
1628   esac
1629 done
1630 
1631 if test -n "$ac_prev"; then
1632   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1633   as_fn_error $? "missing argument to $ac_option"
1634 fi
1635 
1636 if test -n "$ac_unrecognized_opts"; then
1637   case $enable_option_checking in
1638     no) ;;
1639     fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1640     *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1641   esac
1642 fi
1643 
1644 # Check all directory arguments for consistency.
1645 for ac_var in   exec_prefix prefix bindir sbindir libexecdir datarootdir \
1646                 datadir sysconfdir sharedstatedir localstatedir includedir \
1647                 oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
1648                 libdir localedir mandir
1649 do
1650   eval ac_val=\$$ac_var
1651   # Remove trailing slashes.
1652   case $ac_val in
1653     */ )
1654       ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
1655       eval $ac_var=\$ac_val;;
1656   esac
1657   # Be sure to have absolute directory names.
1658   case $ac_val in
1659     [\\/$]* | ?:[\\/]* )  continue;;
1660     NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1661   esac
1662   as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1663 done
1664 
1665 # There might be people who depend on the old broken behavior: `$host'
1666 # used to hold the argument of --host etc.
1667 # FIXME: To remove some day.
1668 build=$build_alias
1669 host=$host_alias
1670 target=$target_alias
1671 
1672 # FIXME: To remove some day.
1673 if test "x$host_alias" != x; then
1674   if test "x$build_alias" = x; then
1675     cross_compiling=maybe
1676   elif test "x$build_alias" != "x$host_alias"; then
1677     cross_compiling=yes
1678   fi
1679 fi
1680 
1681 ac_tool_prefix=
1682 test -n "$host_alias" && ac_tool_prefix=$host_alias-
1683 
1684 test "$silent" = yes && exec 6>/dev/null
1685 
1686 
1687 ac_pwd=`pwd` && test -n "$ac_pwd" &&
1688 ac_ls_di=`ls -di .` &&
1689 ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1690   as_fn_error $? "working directory cannot be determined"
1691 test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1692   as_fn_error $? "pwd does not report name of working directory"
1693 
1694 
1695 # Find the source files, if location was not specified.
1696 if test -z "$srcdir"; then
1697   ac_srcdir_defaulted=yes
1698   # Try the directory containing this script, then the parent directory.
1699   ac_confdir=`$as_dirname -- "$as_myself" ||
1700 $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1701          X"$as_myself" : 'X\(//\)[^/]' \| \
1702          X"$as_myself" : 'X\(//\)$' \| \
1703          X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
1704 $as_echo X"$as_myself" |
1705     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
1706             s//\1/
1707             q
1708           }
1709           /^X\(\/\/\)[^/].*/{
1710             s//\1/
1711             q
1712           }
1713           /^X\(\/\/\)$/{
1714             s//\1/
1715             q
1716           }
1717           /^X\(\/\).*/{
1718             s//\1/
1719             q
1720           }
1721           s/.*/./; q'`
1722   srcdir=$ac_confdir
1723   if test ! -r "$srcdir/$ac_unique_file"; then
1724     srcdir=..
1725   fi
1726 else
1727   ac_srcdir_defaulted=no
1728 fi
1729 if test ! -r "$srcdir/$ac_unique_file"; then
1730   test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1731   as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1732 fi
1733 ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1734 ac_abs_confdir=`(
1735         cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1736         pwd)`
1737 # When building in place, set srcdir=.
1738 if test "$ac_abs_confdir" = "$ac_pwd"; then
1739   srcdir=.
1740 fi
1741 # Remove unnecessary trailing slashes from srcdir.
1742 # Double slashes in file names in object file debugging info
1743 # mess up M-x gdb in Emacs.
1744 case $srcdir in
1745 */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
1746 esac
1747 for ac_var in $ac_precious_vars; do
1748   eval ac_env_${ac_var}_set=\${${ac_var}+set}
1749   eval ac_env_${ac_var}_value=\$${ac_var}
1750   eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
1751   eval ac_cv_env_${ac_var}_value=\$${ac_var}
1752 done
1753 
1754 #
1755 # Report the --help message.
1756 #
1757 if test "$ac_init_help" = "long"; then
1758   # Omit some internal or obsolete options to make the list less imposing.
1759   # This message is too long to be a string in the A/UX 3.1 sh.
1760   cat <<_ACEOF
1761 \`configure' configures OpenJDK jdk9 to adapt to many kinds of systems.
1762 
1763 Usage: $0 [OPTION]... [VAR=VALUE]...
1764 
1765 To assign environment variables (e.g., CC, CFLAGS...), specify them as
1766 VAR=VALUE.  See below for descriptions of some of the useful variables.
1767 
1768 Defaults for the options are specified in brackets.
1769 
1770 Configuration:
1771   -h, --help              display this help and exit
1772       --help=short        display options specific to this package
1773       --help=recursive    display the short help of all the included packages
1774   -V, --version           display version information and exit
1775   -q, --quiet, --silent   do not print \`checking ...' messages
1776       --cache-file=FILE   cache test results in FILE [disabled]
1777   -C, --config-cache      alias for \`--cache-file=config.cache'
1778   -n, --no-create         do not create output files
1779       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
1780 
1781 Installation directories:
1782   --prefix=PREFIX         install architecture-independent files in PREFIX
1783                           [$ac_default_prefix]
1784   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
1785                           [PREFIX]
1786 
1787 By default, \`make install' will install all the files in
1788 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
1789 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
1790 for instance \`--prefix=\$HOME'.
1791 
1792 For better control, use the options below.
1793 
1794 Fine tuning of the installation directories:
1795   --bindir=DIR            user executables [EPREFIX/bin]
1796   --sbindir=DIR           system admin executables [EPREFIX/sbin]
1797   --libexecdir=DIR        program executables [EPREFIX/libexec]
1798   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
1799   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
1800   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
1801   --libdir=DIR            object code libraries [EPREFIX/lib]
1802   --includedir=DIR        C header files [PREFIX/include]
1803   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
1804   --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
1805   --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
1806   --infodir=DIR           info documentation [DATAROOTDIR/info]
1807   --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
1808   --mandir=DIR            man documentation [DATAROOTDIR/man]
1809   --docdir=DIR            documentation root [DATAROOTDIR/doc/openjdk]
1810   --htmldir=DIR           html documentation [DOCDIR]
1811   --dvidir=DIR            dvi documentation [DOCDIR]
1812   --pdfdir=DIR            pdf documentation [DOCDIR]
1813   --psdir=DIR             ps documentation [DOCDIR]
1814 _ACEOF
1815 
1816   cat <<\_ACEOF
1817 
1818 X features:
1819   --x-includes=DIR    X include files are in DIR
1820   --x-libraries=DIR   X library files are in DIR
1821 
1822 System types:
1823   --build=BUILD     configure for building on BUILD [guessed]
1824   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
1825   --target=TARGET   configure for building compilers for TARGET [HOST]
1826 _ACEOF
1827 fi
1828 
1829 if test -n "$ac_init_help"; then
1830   case $ac_init_help in
1831      short | recursive ) echo "Configuration of OpenJDK jdk9:";;
1832    esac
1833   cat <<\_ACEOF
1834 
1835 Optional Features:
1836   --disable-option-checking  ignore unrecognized --enable/--with options
1837   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1838   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
1839   --enable-openjdk-only   suppress building custom source even if present
1840                           [disabled]
1841   --enable-debug          set the debug level to fastdebug (shorthand for
1842                           --with-debug-level=fastdebug) [disabled]
1843   --disable-headful       disable building headful support (graphical UI
1844                           support) [enabled]
1845   --enable-hotspot-test-in-build
1846                           run the Queens test after Hotspot build [disabled]
1847   --enable-unlimited-crypto
1848                           Enable unlimited crypto policy [disabled]
1849   --enable-rmiconnector-iiop
1850                           enable the JMX RMIConnector iiop transport
1851                           [disabled]
1852   --disable-debug-symbols disable generation of debug symbols [enabled]
1853   --disable-zip-debug-info
1854                           disable zipping of debug-info files [enabled]
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-target-bits      build 32-bit or 64-bit binaries (for platforms that
1871                           support it), e.g. --with-target-bits=32 [guessed]
1872   --with-custom-make-dir  Deprecated. Option is kept for backwards
1873                           compatibility and is ignored
1874   --with-jdk-variant      JDK variant to build (normal) [normal]
1875   --with-jvm-interpreter  JVM interpreter to build (template, cpp) [template]
1876   --with-jvm-variants     JVM variants (separated by commas) to build (server,
1877                           client, minimal1, kernel, zero, zeroshark, core)
1878                           [server]
1879   --with-debug-level      set the debug level (release, fastdebug, slowdebug,
1880                           optimized (HotSpot build only)) [release]
1881   --with-devkit           use this devkit for compilers, tools and resources
1882   --with-sys-root         alias for --with-sysroot for backwards compatability
1883   --with-sysroot          use this directory as sysroot
1884   --with-tools-dir        alias for --with-toolchain-path for backwards
1885                           compatibility
1886   --with-toolchain-path   prepend these directories when searching for
1887                           toolchain binaries (compilers etc)
1888   --with-extra-path       prepend these directories to the default path
1889   --with-sdk-name         use the platform SDK of the given name. [macosx]
1890   --with-conf-name        use this as the name of the configuration [generated
1891                           from important configuration options]
1892   --with-output-sync      set make output sync type if supported by make.
1893                           [recurse]
1894   --with-builddeps-conf   use this configuration file for the builddeps
1895   --with-builddeps-server download and use build dependencies from this server
1896                           url
1897   --with-builddeps-dir    store downloaded build dependencies here
1898                           [/localhome/builddeps]
1899   --with-builddeps-group  chgrp the downloaded build dependencies to this
1900                           group
1901   --with-cacerts-file     specify alternative cacerts file
1902   --with-milestone        Set milestone value for build [internal]
1903   --with-update-version   Set update version value for build [b00]
1904   --with-user-release-suffix
1905                           Add a custom string to the version string if build
1906                           number is not set.[username_builddateb00]
1907   --with-build-number     Set build number value for build [b00]
1908   --with-copyright-year   Set copyright year value for build [current year]
1909   --with-boot-jdk         path to Boot JDK (used to bootstrap build) [probed]
1910   --with-add-source-root  for each and every source directory, look in this
1911                           additional source root for the same directory; if it
1912                           exists and have files in it, include it in the build
1913   --with-override-source-root
1914                           for each and every source directory, look in this
1915                           override source root for the same directory; if it
1916                           exists, use that directory instead and ignore the
1917                           directory in the original source root
1918   --with-adds-and-overrides
1919                           use the subdirs 'adds' and 'overrides' in the
1920                           specified directory as add-source-root and
1921                           override-source-root
1922   --with-override-langtools
1923                           use this langtools dir for the build
1924   --with-override-corba   use this corba dir for the build
1925   --with-override-jaxp    use this jaxp dir for the build
1926   --with-override-jaxws   use this jaxws dir for the build
1927   --with-override-hotspot use this hotspot dir for the build
1928   --with-override-nashorn use this nashorn dir for the build
1929   --with-override-jdk     use this jdk dir for the build
1930   --with-import-hotspot   import hotspot binaries from this jdk image or
1931                           hotspot build dist dir instead of building from
1932                           source
1933   --with-toolchain-type   the toolchain type (or family) to use, use '--help'
1934                           to show possible values [platform dependent]
1935   --with-toolchain-version
1936                           the version of the toolchain to look for, use
1937                           '--help' to show possible values [platform
1938                           dependent]
1939   --with-jtreg            Regression Test Harness [probed]
1940   --with-extra-cflags     extra flags to be used when compiling jdk c-files
1941   --with-extra-cxxflags   extra flags to be used when compiling jdk c++-files
1942   --with-extra-ldflags    extra flags to be used when linking jdk
1943   --with-x                use the X Window System
1944   --with-cups             specify prefix directory for the cups package
1945                           (expecting the headers under PATH/include)
1946   --with-cups-include     specify directory for the cups include files
1947   --with-freetype         specify prefix directory for the freetype package
1948                           (expecting the libraries under PATH/lib and the
1949                           headers under PATH/include)
1950   --with-freetype-include specify directory for the freetype include files
1951   --with-freetype-lib     specify directory for the freetype library
1952   --with-freetype-src     specify directory with freetype sources to
1953                           automatically build the library (experimental,
1954                           Windows-only)
1955   --with-alsa             specify prefix directory for the alsa package
1956                           (expecting the libraries under PATH/lib and the
1957                           headers under PATH/include)
1958   --with-alsa-include     specify directory for the alsa include files
1959   --with-alsa-lib         specify directory for the alsa library
1960   --with-libjpeg          use libjpeg from build system or OpenJDK source
1961                           (system, bundled) [bundled]
1962   --with-giflib           use giflib from build system or OpenJDK source
1963                           (system, bundled) [bundled]
1964   --with-lcms             use lcms2 from build system or OpenJDK source
1965                           (system, bundled) [bundled]
1966   --with-libpng           use libpng from build system or OpenJDK source
1967                           (system, bundled) [bundled]
1968   --with-zlib             use zlib from build system or OpenJDK source
1969                           (system, bundled) [bundled]
1970   --with-stdc++lib=<static>,<dynamic>,<default>
1971                           force linking of the C++ runtime on Linux to either
1972                           static or dynamic, default is static with dynamic as
1973                           fallback
1974   --with-msvcr-dll        path to microsoft C runtime dll (msvcr*.dll)
1975                           (Windows only) [probed]
1976   --with-msvcp-dll        path to microsoft C++ runtime dll (msvcp*.dll)
1977                           (Windows only) [probed]
1978   --with-dxsdk            Deprecated. Option is kept for backwards
1979                           compatibility and is ignored
1980   --with-dxsdk-lib        Deprecated. Option is kept for backwards
1981                           compatibility and is ignored
1982   --with-dxsdk-include    Deprecated. Option is kept for backwards
1983                           compatibility and is ignored
1984   --with-num-cores        number of cores in the build system, e.g.
1985                           --with-num-cores=8 [probed]
1986   --with-memory-size      memory (in MB) available in the build system, e.g.
1987                           --with-memory-size=1024 [probed]
1988   --with-jobs             number of parallel jobs to let make run [calculated
1989                           based on cores and memory]
1990   --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
1991                           invocations of boot JDK, overriding the default
1992                           values, e.g --with-boot-jdk-jvmargs="-Xmx8G
1993                           -enableassertions"
1994   --with-sjavac-server-java
1995                           use this java binary for running the sjavac
1996                           background server [Boot JDK java]
1997   --with-ccache-dir       where to store ccache files [~/.ccache]
1998 
1999 Some influential environment variables:
2000   BASENAME    Override default value for BASENAME
2001   BASH        Override default value for BASH
2002   CAT         Override default value for CAT
2003   CHMOD       Override default value for CHMOD
2004   CMP         Override default value for CMP
2005   COMM        Override default value for COMM
2006   CP          Override default value for CP
2007   CUT         Override default value for CUT
2008   DATE        Override default value for DATE
2009   DIFF        Override default value for DIFF
2010   DIRNAME     Override default value for DIRNAME
2011   ECHO        Override default value for ECHO
2012   EXPR        Override default value for EXPR
2013   FILE        Override default value for FILE
2014   FIND        Override default value for FIND
2015   HEAD        Override default value for HEAD
2016   LN          Override default value for LN
2017   LS          Override default value for LS
2018   MKDIR       Override default value for MKDIR
2019   MKTEMP      Override default value for MKTEMP
2020   MV          Override default value for MV
2021   NAWK        Override default value for NAWK
2022   PRINTF      Override default value for PRINTF
2023   RM          Override default value for RM
2024   SH          Override default value for SH
2025   SORT        Override default value for SORT
2026   TAIL        Override default value for TAIL
2027   TAR         Override default value for TAR
2028   TEE         Override default value for TEE
2029   TOUCH       Override default value for TOUCH
2030   TR          Override default value for TR
2031   UNAME       Override default value for UNAME
2032   UNIQ        Override default value for UNIQ
2033   WC          Override default value for WC
2034   WHICH       Override default value for WHICH
2035   XARGS       Override default value for XARGS
2036   AWK         Override default value for AWK
2037   GREP        Override default value for GREP
2038   EGREP       Override default value for EGREP
2039   FGREP       Override default value for FGREP
2040   SED         Override default value for SED
2041   CYGPATH     Override default value for CYGPATH
2042   READLINK    Override default value for READLINK
2043   DF          Override default value for DF
2044   SETFILE     Override default value for SETFILE
2045   CPIO        Override default value for CPIO
2046   UNZIP       Override default value for UNZIP
2047   ZIP         Override default value for ZIP
2048   LDD         Override default value for LDD
2049   OTOOL       Override default value for OTOOL
2050   READELF     Override default value for READELF
2051   HG          Override default value for HG
2052   STAT        Override default value for STAT
2053   TIME        Override default value for TIME
2054   DSYMUTIL    Override default value for DSYMUTIL
2055   XATTR       Override default value for XATTR
2056   CODESIGN    Override default value for CODESIGN
2057   PKG_CONFIG  path to pkg-config utility
2058   JAVA        Override default value for JAVA
2059   JAVAC       Override default value for JAVAC
2060   JAVAH       Override default value for JAVAH
2061   JAR         Override default value for JAR
2062   NATIVE2ASCII
2063               Override default value for NATIVE2ASCII
2064   JARSIGNER   Override default value for JARSIGNER
2065   CC          C compiler command
2066   CFLAGS      C compiler flags
2067   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
2068               nonstandard directory <lib dir>
2069   LIBS        libraries to pass to the linker, e.g. -l<library>
2070   CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
2071               you have headers in a nonstandard directory <include dir>
2072   CXX         C++ compiler command
2073   CXXFLAGS    C++ compiler flags
2074   CPP         C preprocessor
2075   CXXCPP      C++ preprocessor
2076   AS          Override default value for AS
2077   AR          Override default value for AR
2078   LIPO        Override default value for LIPO
2079   STRIP       Override default value for STRIP
2080   NM          Override default value for NM
2081   GNM         Override default value for GNM
2082   MCS         Override default value for MCS
2083   OBJCOPY     Override default value for OBJCOPY
2084   OBJDUMP     Override default value for OBJDUMP
2085   BUILD_CC    Override default value for BUILD_CC
2086   BUILD_CXX   Override default value for BUILD_CXX
2087   BUILD_LD    Override default value for BUILD_LD
2088   JTREGEXE    Override default value for JTREGEXE
2089   XMKMF       Path to xmkmf, Makefile generator for X Window System
2090   FREETYPE_CFLAGS
2091               C compiler flags for FREETYPE, overriding pkg-config
2092   FREETYPE_LIBS
2093               linker flags for FREETYPE, overriding pkg-config
2094   ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
2095   ALSA_LIBS   linker flags for ALSA, overriding pkg-config
2096   LCMS_CFLAGS C compiler flags for LCMS, overriding pkg-config
2097   LCMS_LIBS   linker flags for LCMS, overriding pkg-config
2098   PNG_CFLAGS  C compiler flags for PNG, overriding pkg-config
2099   PNG_LIBS    linker flags for PNG, overriding pkg-config
2100   LIBFFI_CFLAGS
2101               C compiler flags for LIBFFI, overriding pkg-config
2102   LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
2103   CCACHE      Override default value for CCACHE
2104 
2105 Use these variables to override the choices made by `configure' or to help
2106 it to find libraries and programs with nonstandard names/locations.
2107 
2108 Report bugs to <build-dev@openjdk.java.net>.
2109 OpenJDK home page: <http://openjdk.java.net>.
2110 _ACEOF
2111 ac_status=$?
2112 fi
2113 
2114 if test "$ac_init_help" = "recursive"; then
2115   # If there are subdirs, report their specific --help.
2116   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
2117     test -d "$ac_dir" ||
2118       { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
2119       continue
2120     ac_builddir=.
2121 
2122 case "$ac_dir" in
2123 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
2124 *)
2125   ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
2126   # A ".." for each directory in $ac_dir_suffix.
2127   ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
2128   case $ac_top_builddir_sub in
2129   "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
2130   *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
2131   esac ;;
2132 esac
2133 ac_abs_top_builddir=$ac_pwd
2134 ac_abs_builddir=$ac_pwd$ac_dir_suffix
2135 # for backward compatibility:
2136 ac_top_builddir=$ac_top_build_prefix
2137 
2138 case $srcdir in
2139   .)  # We are building in place.
2140     ac_srcdir=.
2141     ac_top_srcdir=$ac_top_builddir_sub
2142     ac_abs_top_srcdir=$ac_pwd ;;
2143   [\\/]* | ?:[\\/]* )  # Absolute name.
2144     ac_srcdir=$srcdir$ac_dir_suffix;
2145     ac_top_srcdir=$srcdir
2146     ac_abs_top_srcdir=$srcdir ;;
2147   *) # Relative name.
2148     ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
2149     ac_top_srcdir=$ac_top_build_prefix$srcdir
2150     ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
2151 esac
2152 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
2153 
2154     cd "$ac_dir" || { ac_status=$?; continue; }
2155     # Check for guested configure.
2156     if test -f "$ac_srcdir/configure.gnu"; then
2157       echo &&
2158       $SHELL "$ac_srcdir/configure.gnu" --help=recursive
2159     elif test -f "$ac_srcdir/configure"; then
2160       echo &&
2161       $SHELL "$ac_srcdir/configure" --help=recursive
2162     else
2163       $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
2164     fi || ac_status=$?
2165     cd "$ac_pwd" || { ac_status=$?; break; }
2166   done
2167 fi
2168 
2169 test -n "$ac_init_help" && exit $ac_status
2170 if $ac_init_version; then
2171   cat <<\_ACEOF
2172 OpenJDK configure jdk9
2173 generated by GNU Autoconf 2.69
2174 
2175 Copyright (C) 2012 Free Software Foundation, Inc.
2176 This configure script is free software; the Free Software Foundation
2177 gives unlimited permission to copy, distribute and modify it.
2178 _ACEOF
2179   exit
2180 fi
2181 
2182 ## ------------------------ ##
2183 ## Autoconf initialization. ##
2184 ## ------------------------ ##
2185 
2186 # ac_fn_c_try_compile LINENO
2187 # --------------------------
2188 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2189 ac_fn_c_try_compile ()
2190 {
2191   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2192   rm -f conftest.$ac_objext
2193   if { { ac_try="$ac_compile"
2194 case "(($ac_try" in
2195   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2196   *) ac_try_echo=$ac_try;;
2197 esac
2198 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2199 $as_echo "$ac_try_echo"; } >&5
2200   (eval "$ac_compile") 2>conftest.err
2201   ac_status=$?
2202   if test -s conftest.err; then
2203     grep -v '^ *+' conftest.err >conftest.er1
2204     cat conftest.er1 >&5
2205     mv -f conftest.er1 conftest.err
2206   fi
2207   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2208   test $ac_status = 0; } && {
2209          test -z "$ac_c_werror_flag" ||
2210          test ! -s conftest.err
2211        } && test -s conftest.$ac_objext; then :
2212   ac_retval=0
2213 else
2214   $as_echo "$as_me: failed program was:" >&5
2215 sed 's/^/| /' conftest.$ac_ext >&5
2216 
2217         ac_retval=1
2218 fi
2219   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2220   as_fn_set_status $ac_retval
2221 
2222 } # ac_fn_c_try_compile
2223 
2224 # ac_fn_cxx_try_compile LINENO
2225 # ----------------------------
2226 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2227 ac_fn_cxx_try_compile ()
2228 {
2229   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2230   rm -f conftest.$ac_objext
2231   if { { ac_try="$ac_compile"
2232 case "(($ac_try" in
2233   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2234   *) ac_try_echo=$ac_try;;
2235 esac
2236 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2237 $as_echo "$ac_try_echo"; } >&5
2238   (eval "$ac_compile") 2>conftest.err
2239   ac_status=$?
2240   if test -s conftest.err; then
2241     grep -v '^ *+' conftest.err >conftest.er1
2242     cat conftest.er1 >&5
2243     mv -f conftest.er1 conftest.err
2244   fi
2245   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2246   test $ac_status = 0; } && {
2247          test -z "$ac_cxx_werror_flag" ||
2248          test ! -s conftest.err
2249        } && test -s conftest.$ac_objext; then :
2250   ac_retval=0
2251 else
2252   $as_echo "$as_me: failed program was:" >&5
2253 sed 's/^/| /' conftest.$ac_ext >&5
2254 
2255         ac_retval=1
2256 fi
2257   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2258   as_fn_set_status $ac_retval
2259 
2260 } # ac_fn_cxx_try_compile
2261 
2262 # ac_fn_c_try_cpp LINENO
2263 # ----------------------
2264 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2265 ac_fn_c_try_cpp ()
2266 {
2267   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2268   if { { ac_try="$ac_cpp conftest.$ac_ext"
2269 case "(($ac_try" in
2270   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2271   *) ac_try_echo=$ac_try;;
2272 esac
2273 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2274 $as_echo "$ac_try_echo"; } >&5
2275   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2276   ac_status=$?
2277   if test -s conftest.err; then
2278     grep -v '^ *+' conftest.err >conftest.er1
2279     cat conftest.er1 >&5
2280     mv -f conftest.er1 conftest.err
2281   fi
2282   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2283   test $ac_status = 0; } > conftest.i && {
2284          test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
2285          test ! -s conftest.err
2286        }; then :
2287   ac_retval=0
2288 else
2289   $as_echo "$as_me: failed program was:" >&5
2290 sed 's/^/| /' conftest.$ac_ext >&5
2291 
2292     ac_retval=1
2293 fi
2294   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2295   as_fn_set_status $ac_retval
2296 
2297 } # ac_fn_c_try_cpp
2298 
2299 # ac_fn_cxx_try_cpp LINENO
2300 # ------------------------
2301 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2302 ac_fn_cxx_try_cpp ()
2303 {
2304   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2305   if { { ac_try="$ac_cpp conftest.$ac_ext"
2306 case "(($ac_try" in
2307   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2308   *) ac_try_echo=$ac_try;;
2309 esac
2310 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2311 $as_echo "$ac_try_echo"; } >&5
2312   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2313   ac_status=$?
2314   if test -s conftest.err; then
2315     grep -v '^ *+' conftest.err >conftest.er1
2316     cat conftest.er1 >&5
2317     mv -f conftest.er1 conftest.err
2318   fi
2319   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2320   test $ac_status = 0; } > conftest.i && {
2321          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2322          test ! -s conftest.err
2323        }; then :
2324   ac_retval=0
2325 else
2326   $as_echo "$as_me: failed program was:" >&5
2327 sed 's/^/| /' conftest.$ac_ext >&5
2328 
2329     ac_retval=1
2330 fi
2331   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2332   as_fn_set_status $ac_retval
2333 
2334 } # ac_fn_cxx_try_cpp
2335 
2336 # ac_fn_c_try_link LINENO
2337 # -----------------------
2338 # Try to link conftest.$ac_ext, and return whether this succeeded.
2339 ac_fn_c_try_link ()
2340 {
2341   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2342   rm -f conftest.$ac_objext conftest$ac_exeext
2343   if { { ac_try="$ac_link"
2344 case "(($ac_try" in
2345   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2346   *) ac_try_echo=$ac_try;;
2347 esac
2348 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2349 $as_echo "$ac_try_echo"; } >&5
2350   (eval "$ac_link") 2>conftest.err
2351   ac_status=$?
2352   if test -s conftest.err; then
2353     grep -v '^ *+' conftest.err >conftest.er1
2354     cat conftest.er1 >&5
2355     mv -f conftest.er1 conftest.err
2356   fi
2357   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2358   test $ac_status = 0; } && {
2359          test -z "$ac_c_werror_flag" ||
2360          test ! -s conftest.err
2361        } && test -s conftest$ac_exeext && {
2362          test "$cross_compiling" = yes ||
2363          test -x conftest$ac_exeext
2364        }; then :
2365   ac_retval=0
2366 else
2367   $as_echo "$as_me: failed program was:" >&5
2368 sed 's/^/| /' conftest.$ac_ext >&5
2369 
2370         ac_retval=1
2371 fi
2372   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2373   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2374   # interfere with the next link command; also delete a directory that is
2375   # left behind by Apple's compiler.  We do this before executing the actions.
2376   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2377   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2378   as_fn_set_status $ac_retval
2379 
2380 } # ac_fn_c_try_link
2381 
2382 # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2383 # ---------------------------------------------------------
2384 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2385 # the include files in INCLUDES and setting the cache variable VAR
2386 # accordingly.
2387 ac_fn_cxx_check_header_mongrel ()
2388 {
2389   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2390   if eval \${$3+:} false; then :
2391   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2392 $as_echo_n "checking for $2... " >&6; }
2393 if eval \${$3+:} false; then :
2394   $as_echo_n "(cached) " >&6
2395 fi
2396 eval ac_res=\$$3
2397                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2398 $as_echo "$ac_res" >&6; }
2399 else
2400   # Is the header compilable?
2401 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2402 $as_echo_n "checking $2 usability... " >&6; }
2403 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2404 /* end confdefs.h.  */
2405 $4
2406 #include <$2>
2407 _ACEOF
2408 if ac_fn_cxx_try_compile "$LINENO"; then :
2409   ac_header_compiler=yes
2410 else
2411   ac_header_compiler=no
2412 fi
2413 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2414 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2415 $as_echo "$ac_header_compiler" >&6; }
2416 
2417 # Is the header present?
2418 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2419 $as_echo_n "checking $2 presence... " >&6; }
2420 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2421 /* end confdefs.h.  */
2422 #include <$2>
2423 _ACEOF
2424 if ac_fn_cxx_try_cpp "$LINENO"; then :
2425   ac_header_preproc=yes
2426 else
2427   ac_header_preproc=no
2428 fi
2429 rm -f conftest.err conftest.i conftest.$ac_ext
2430 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2431 $as_echo "$ac_header_preproc" >&6; }
2432 
2433 # So?  What about this header?
2434 case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2435   yes:no: )
2436     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2437 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2438     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2439 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2440     ;;
2441   no:yes:* )
2442     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2443 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2444     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
2445 $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
2446     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2447 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2448     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
2449 $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
2450     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2451 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2452 ( $as_echo "## ----------------------------------------- ##
2453 ## Report this to build-dev@openjdk.java.net ##
2454 ## ----------------------------------------- ##"
2455      ) | sed "s/^/$as_me: WARNING:     /" >&2
2456     ;;
2457 esac
2458   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2459 $as_echo_n "checking for $2... " >&6; }
2460 if eval \${$3+:} false; then :
2461   $as_echo_n "(cached) " >&6
2462 else
2463   eval "$3=\$ac_header_compiler"
2464 fi
2465 eval ac_res=\$$3
2466                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2467 $as_echo "$ac_res" >&6; }
2468 fi
2469   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2470 
2471 } # ac_fn_cxx_check_header_mongrel
2472 
2473 # ac_fn_cxx_try_run LINENO
2474 # ------------------------
2475 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2476 # that executables *can* be run.
2477 ac_fn_cxx_try_run ()
2478 {
2479   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2480   if { { ac_try="$ac_link"
2481 case "(($ac_try" in
2482   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2483   *) ac_try_echo=$ac_try;;
2484 esac
2485 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2486 $as_echo "$ac_try_echo"; } >&5
2487   (eval "$ac_link") 2>&5
2488   ac_status=$?
2489   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2490   test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2491   { { case "(($ac_try" in
2492   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2493   *) ac_try_echo=$ac_try;;
2494 esac
2495 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2496 $as_echo "$ac_try_echo"; } >&5
2497   (eval "$ac_try") 2>&5
2498   ac_status=$?
2499   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2500   test $ac_status = 0; }; }; then :
2501   ac_retval=0
2502 else
2503   $as_echo "$as_me: program exited with status $ac_status" >&5
2504        $as_echo "$as_me: failed program was:" >&5
2505 sed 's/^/| /' conftest.$ac_ext >&5
2506 
2507        ac_retval=$ac_status
2508 fi
2509   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2510   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2511   as_fn_set_status $ac_retval
2512 
2513 } # ac_fn_cxx_try_run
2514 
2515 # ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
2516 # ---------------------------------------------------------
2517 # Tests whether HEADER exists and can be compiled using the include files in
2518 # INCLUDES, setting the cache variable VAR accordingly.
2519 ac_fn_cxx_check_header_compile ()
2520 {
2521   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2522   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2523 $as_echo_n "checking for $2... " >&6; }
2524 if eval \${$3+:} false; then :
2525   $as_echo_n "(cached) " >&6
2526 else
2527   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2528 /* end confdefs.h.  */
2529 $4
2530 #include <$2>
2531 _ACEOF
2532 if ac_fn_cxx_try_compile "$LINENO"; then :
2533   eval "$3=yes"
2534 else
2535   eval "$3=no"
2536 fi
2537 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2538 fi
2539 eval ac_res=\$$3
2540                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2541 $as_echo "$ac_res" >&6; }
2542   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2543 
2544 } # ac_fn_cxx_check_header_compile
2545 
2546 # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
2547 # ----------------------------------------------
2548 # Tries to find the compile-time value of EXPR in a program that includes
2549 # INCLUDES, setting VAR accordingly. Returns whether the value could be
2550 # computed
2551 ac_fn_cxx_compute_int ()
2552 {
2553   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2554   if test "$cross_compiling" = yes; then
2555     # Depending upon the size, compute the lo and hi bounds.
2556 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2557 /* end confdefs.h.  */
2558 $4
2559 int
2560 main ()
2561 {
2562 static int test_array [1 - 2 * !(($2) >= 0)];
2563 test_array [0] = 0;
2564 return test_array [0];
2565 
2566   ;
2567   return 0;
2568 }
2569 _ACEOF
2570 if ac_fn_cxx_try_compile "$LINENO"; then :
2571   ac_lo=0 ac_mid=0
2572   while :; do
2573     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2574 /* end confdefs.h.  */
2575 $4
2576 int
2577 main ()
2578 {
2579 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2580 test_array [0] = 0;
2581 return test_array [0];
2582 
2583   ;
2584   return 0;
2585 }
2586 _ACEOF
2587 if ac_fn_cxx_try_compile "$LINENO"; then :
2588   ac_hi=$ac_mid; break
2589 else
2590   as_fn_arith $ac_mid + 1 && ac_lo=$as_val
2591                         if test $ac_lo -le $ac_mid; then
2592                           ac_lo= ac_hi=
2593                           break
2594                         fi
2595                         as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
2596 fi
2597 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2598   done
2599 else
2600   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2601 /* end confdefs.h.  */
2602 $4
2603 int
2604 main ()
2605 {
2606 static int test_array [1 - 2 * !(($2) < 0)];
2607 test_array [0] = 0;
2608 return test_array [0];
2609 
2610   ;
2611   return 0;
2612 }
2613 _ACEOF
2614 if ac_fn_cxx_try_compile "$LINENO"; then :
2615   ac_hi=-1 ac_mid=-1
2616   while :; do
2617     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2618 /* end confdefs.h.  */
2619 $4
2620 int
2621 main ()
2622 {
2623 static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2624 test_array [0] = 0;
2625 return test_array [0];
2626 
2627   ;
2628   return 0;
2629 }
2630 _ACEOF
2631 if ac_fn_cxx_try_compile "$LINENO"; then :
2632   ac_lo=$ac_mid; break
2633 else
2634   as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2635                         if test $ac_mid -le $ac_hi; then
2636                           ac_lo= ac_hi=
2637                           break
2638                         fi
2639                         as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2640 fi
2641 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2642   done
2643 else
2644   ac_lo= ac_hi=
2645 fi
2646 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2647 fi
2648 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2649 # Binary search between lo and hi bounds.
2650 while test "x$ac_lo" != "x$ac_hi"; do
2651   as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2652   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2653 /* end confdefs.h.  */
2654 $4
2655 int
2656 main ()
2657 {
2658 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2659 test_array [0] = 0;
2660 return test_array [0];
2661 
2662   ;
2663   return 0;
2664 }
2665 _ACEOF
2666 if ac_fn_cxx_try_compile "$LINENO"; then :
2667   ac_hi=$ac_mid
2668 else
2669   as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2670 fi
2671 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2672 done
2673 case $ac_lo in #((
2674 ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2675 '') ac_retval=1 ;;
2676 esac
2677   else
2678     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2679 /* end confdefs.h.  */
2680 $4
2681 static long int longval () { return $2; }
2682 static unsigned long int ulongval () { return $2; }
2683 #include <stdio.h>
2684 #include <stdlib.h>
2685 int
2686 main ()
2687 {
2688 
2689   FILE *f = fopen ("conftest.val", "w");
2690   if (! f)
2691     return 1;
2692   if (($2) < 0)
2693     {
2694       long int i = longval ();
2695       if (i != ($2))
2696         return 1;
2697       fprintf (f, "%ld", i);
2698     }
2699   else
2700     {
2701       unsigned long int i = ulongval ();
2702       if (i != ($2))
2703         return 1;
2704       fprintf (f, "%lu", i);
2705     }
2706   /* Do not output a trailing newline, as this causes \r\n confusion
2707      on some platforms.  */
2708   return ferror (f) || fclose (f) != 0;
2709 
2710   ;
2711   return 0;
2712 }
2713 _ACEOF
2714 if ac_fn_cxx_try_run "$LINENO"; then :
2715   echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2716 else
2717   ac_retval=1
2718 fi
2719 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2720   conftest.$ac_objext conftest.beam conftest.$ac_ext
2721 rm -f conftest.val
2722 
2723   fi
2724   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2725   as_fn_set_status $ac_retval
2726 
2727 } # ac_fn_cxx_compute_int
2728 
2729 # ac_fn_cxx_try_link LINENO
2730 # -------------------------
2731 # Try to link conftest.$ac_ext, and return whether this succeeded.
2732 ac_fn_cxx_try_link ()
2733 {
2734   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2735   rm -f conftest.$ac_objext conftest$ac_exeext
2736   if { { ac_try="$ac_link"
2737 case "(($ac_try" in
2738   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2739   *) ac_try_echo=$ac_try;;
2740 esac
2741 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2742 $as_echo "$ac_try_echo"; } >&5
2743   (eval "$ac_link") 2>conftest.err
2744   ac_status=$?
2745   if test -s conftest.err; then
2746     grep -v '^ *+' conftest.err >conftest.er1
2747     cat conftest.er1 >&5
2748     mv -f conftest.er1 conftest.err
2749   fi
2750   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2751   test $ac_status = 0; } && {
2752          test -z "$ac_cxx_werror_flag" ||
2753          test ! -s conftest.err
2754        } && test -s conftest$ac_exeext && {
2755          test "$cross_compiling" = yes ||
2756          test -x conftest$ac_exeext
2757        }; then :
2758   ac_retval=0
2759 else
2760   $as_echo "$as_me: failed program was:" >&5
2761 sed 's/^/| /' conftest.$ac_ext >&5
2762 
2763         ac_retval=1
2764 fi
2765   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2766   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2767   # interfere with the next link command; also delete a directory that is
2768   # left behind by Apple's compiler.  We do this before executing the actions.
2769   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2770   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2771   as_fn_set_status $ac_retval
2772 
2773 } # ac_fn_cxx_try_link
2774 
2775 # ac_fn_cxx_check_func LINENO FUNC VAR
2776 # ------------------------------------
2777 # Tests whether FUNC exists, setting the cache variable VAR accordingly
2778 ac_fn_cxx_check_func ()
2779 {
2780   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2781   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2782 $as_echo_n "checking for $2... " >&6; }
2783 if eval \${$3+:} false; then :
2784   $as_echo_n "(cached) " >&6
2785 else
2786   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2787 /* end confdefs.h.  */
2788 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
2789    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
2790 #define $2 innocuous_$2
2791 
2792 /* System header to define __stub macros and hopefully few prototypes,
2793     which can conflict with char $2 (); below.
2794     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2795     <limits.h> exists even on freestanding compilers.  */
2796 
2797 #ifdef __STDC__
2798 # include <limits.h>
2799 #else
2800 # include <assert.h>
2801 #endif
2802 
2803 #undef $2
2804 
2805 /* Override any GCC internal prototype to avoid an error.
2806    Use char because int might match the return type of a GCC
2807    builtin and then its argument prototype would still apply.  */
2808 #ifdef __cplusplus
2809 extern "C"
2810 #endif
2811 char $2 ();
2812 /* The GNU C library defines this for functions which it implements
2813     to always fail with ENOSYS.  Some functions are actually named
2814     something starting with __ and the normal name is an alias.  */
2815 #if defined __stub_$2 || defined __stub___$2
2816 choke me
2817 #endif
2818 
2819 int
2820 main ()
2821 {
2822 return $2 ();
2823   ;
2824   return 0;
2825 }
2826 _ACEOF
2827 if ac_fn_cxx_try_link "$LINENO"; then :
2828   eval "$3=yes"
2829 else
2830   eval "$3=no"
2831 fi
2832 rm -f core conftest.err conftest.$ac_objext \
2833     conftest$ac_exeext conftest.$ac_ext
2834 fi
2835 eval ac_res=\$$3
2836                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2837 $as_echo "$ac_res" >&6; }
2838   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2839 
2840 } # ac_fn_cxx_check_func
2841 
2842 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
2843 # -------------------------------------------------------
2844 # Tests whether HEADER exists and can be compiled using the include files in
2845 # INCLUDES, setting the cache variable VAR accordingly.
2846 ac_fn_c_check_header_compile ()
2847 {
2848   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2849   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2850 $as_echo_n "checking for $2... " >&6; }
2851 if eval \${$3+:} false; then :
2852   $as_echo_n "(cached) " >&6
2853 else
2854   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2855 /* end confdefs.h.  */
2856 $4
2857 #include <$2>
2858 _ACEOF
2859 if ac_fn_c_try_compile "$LINENO"; then :
2860   eval "$3=yes"
2861 else
2862   eval "$3=no"
2863 fi
2864 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2865 fi
2866 eval ac_res=\$$3
2867                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2868 $as_echo "$ac_res" >&6; }
2869   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2870 
2871 } # ac_fn_c_check_header_compile
2872 cat >config.log <<_ACEOF
2873 This file contains any messages produced by compilers while
2874 running configure, to aid debugging if configure makes a mistake.
2875 
2876 It was created by OpenJDK $as_me jdk9, which was
2877 generated by GNU Autoconf 2.69.  Invocation command line was
2878 
2879   $ $0 $@
2880 
2881 _ACEOF
2882 exec 5>>config.log
2883 {
2884 cat <<_ASUNAME
2885 ## --------- ##
2886 ## Platform. ##
2887 ## --------- ##
2888 
2889 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
2890 uname -m = `(uname -m) 2>/dev/null || echo unknown`
2891 uname -r = `(uname -r) 2>/dev/null || echo unknown`
2892 uname -s = `(uname -s) 2>/dev/null || echo unknown`
2893 uname -v = `(uname -v) 2>/dev/null || echo unknown`
2894 
2895 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
2896 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
2897 
2898 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
2899 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
2900 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
2901 /usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
2902 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
2903 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
2904 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
2905 
2906 _ASUNAME
2907 
2908 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2909 for as_dir in $PATH
2910 do
2911   IFS=$as_save_IFS
2912   test -z "$as_dir" && as_dir=.
2913     $as_echo "PATH: $as_dir"
2914   done
2915 IFS=$as_save_IFS
2916 
2917 } >&5
2918 
2919 cat >&5 <<_ACEOF
2920 
2921 
2922 ## ----------- ##
2923 ## Core tests. ##
2924 ## ----------- ##
2925 
2926 _ACEOF
2927 
2928 
2929 # Keep a trace of the command line.
2930 # Strip out --no-create and --no-recursion so they do not pile up.
2931 # Strip out --silent because we don't want to record it for future runs.
2932 # Also quote any args containing shell meta-characters.
2933 # Make two passes to allow for proper duplicate-argument suppression.
2934 ac_configure_args=
2935 ac_configure_args0=
2936 ac_configure_args1=
2937 ac_must_keep_next=false
2938 for ac_pass in 1 2
2939 do
2940   for ac_arg
2941   do
2942     case $ac_arg in
2943     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
2944     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
2945     | -silent | --silent | --silen | --sile | --sil)
2946       continue ;;
2947     *\'*)
2948       ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
2949     esac
2950     case $ac_pass in
2951     1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2952     2)
2953       as_fn_append ac_configure_args1 " '$ac_arg'"
2954       if test $ac_must_keep_next = true; then
2955         ac_must_keep_next=false # Got value, back to normal.
2956       else
2957         case $ac_arg in
2958           *=* | --config-cache | -C | -disable-* | --disable-* \
2959           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
2960           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
2961           | -with-* | --with-* | -without-* | --without-* | --x)
2962             case "$ac_configure_args0 " in
2963               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
2964             esac
2965             ;;
2966           -* ) ac_must_keep_next=true ;;
2967         esac
2968       fi
2969       as_fn_append ac_configure_args " '$ac_arg'"
2970       ;;
2971     esac
2972   done
2973 done
2974 { ac_configure_args0=; unset ac_configure_args0;}
2975 { ac_configure_args1=; unset ac_configure_args1;}
2976 
2977 # When interrupted or exit'd, cleanup temporary files, and complete
2978 # config.log.  We remove comments because anyway the quotes in there
2979 # would cause problems or look ugly.
2980 # WARNING: Use '\'' to represent an apostrophe within the trap.
2981 # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
2982 trap 'exit_status=$?
2983   # Save into config.log some information that might help in debugging.
2984   {
2985     echo
2986 
2987     $as_echo "## ---------------- ##
2988 ## Cache variables. ##
2989 ## ---------------- ##"
2990     echo
2991     # The following way of writing the cache mishandles newlines in values,
2992 (
2993   for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
2994     eval ac_val=\$$ac_var
2995     case $ac_val in #(
2996     *${as_nl}*)
2997       case $ac_var in #(
2998       *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
2999 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
3000       esac
3001       case $ac_var in #(
3002       _ | IFS | as_nl) ;; #(
3003       BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
3004       *) { eval $ac_var=; unset $ac_var;} ;;
3005       esac ;;
3006     esac
3007   done
3008   (set) 2>&1 |
3009     case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
3010     *${as_nl}ac_space=\ *)
3011       sed -n \
3012         "s/'\''/'\''\\\\'\'''\''/g;
3013           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
3014       ;; #(
3015     *)
3016       sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
3017       ;;
3018     esac |
3019     sort
3020 )
3021     echo
3022 
3023     $as_echo "## ----------------- ##
3024 ## Output variables. ##
3025 ## ----------------- ##"
3026     echo
3027     for ac_var in $ac_subst_vars
3028     do
3029       eval ac_val=\$$ac_var
3030       case $ac_val in
3031       *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3032       esac
3033       $as_echo "$ac_var='\''$ac_val'\''"
3034     done | sort
3035     echo
3036 
3037     if test -n "$ac_subst_files"; then
3038       $as_echo "## ------------------- ##
3039 ## File substitutions. ##
3040 ## ------------------- ##"
3041       echo
3042       for ac_var in $ac_subst_files
3043       do
3044         eval ac_val=\$$ac_var
3045         case $ac_val in
3046         *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3047         esac
3048         $as_echo "$ac_var='\''$ac_val'\''"
3049       done | sort
3050       echo
3051     fi
3052 
3053     if test -s confdefs.h; then
3054       $as_echo "## ----------- ##
3055 ## confdefs.h. ##
3056 ## ----------- ##"
3057       echo
3058       cat confdefs.h
3059       echo
3060     fi
3061     test "$ac_signal" != 0 &&
3062       $as_echo "$as_me: caught signal $ac_signal"
3063     $as_echo "$as_me: exit $exit_status"
3064   } >&5
3065   rm -f core *.core core.conftest.* &&
3066     rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
3067     exit $exit_status
3068 ' 0
3069 for ac_signal in 1 2 13 15; do
3070   trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
3071 done
3072 ac_signal=0
3073 
3074 # confdefs.h avoids OS command line length limits that DEFS can exceed.
3075 rm -f -r conftest* confdefs.h
3076 
3077 $as_echo "/* confdefs.h */" > confdefs.h
3078 
3079 # Predefined preprocessor variables.
3080 
3081 cat >>confdefs.h <<_ACEOF
3082 #define PACKAGE_NAME "$PACKAGE_NAME"
3083 _ACEOF
3084 
3085 cat >>confdefs.h <<_ACEOF
3086 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
3087 _ACEOF
3088 
3089 cat >>confdefs.h <<_ACEOF
3090 #define PACKAGE_VERSION "$PACKAGE_VERSION"
3091 _ACEOF
3092 
3093 cat >>confdefs.h <<_ACEOF
3094 #define PACKAGE_STRING "$PACKAGE_STRING"
3095 _ACEOF
3096 
3097 cat >>confdefs.h <<_ACEOF
3098 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
3099 _ACEOF
3100 
3101 cat >>confdefs.h <<_ACEOF
3102 #define PACKAGE_URL "$PACKAGE_URL"
3103 _ACEOF
3104 
3105 
3106 # Let the site file select an alternate cache file if it wants to.
3107 # Prefer an explicitly selected file to automatically selected ones.
3108 ac_site_file1=NONE
3109 ac_site_file2=NONE
3110 if test -n "$CONFIG_SITE"; then
3111   # We do not want a PATH search for config.site.
3112   case $CONFIG_SITE in #((
3113     -*)  ac_site_file1=./$CONFIG_SITE;;
3114     */*) ac_site_file1=$CONFIG_SITE;;
3115     *)   ac_site_file1=./$CONFIG_SITE;;
3116   esac
3117 elif test "x$prefix" != xNONE; then
3118   ac_site_file1=$prefix/share/config.site
3119   ac_site_file2=$prefix/etc/config.site
3120 else
3121   ac_site_file1=$ac_default_prefix/share/config.site
3122   ac_site_file2=$ac_default_prefix/etc/config.site
3123 fi
3124 for ac_site_file in "$ac_site_file1" "$ac_site_file2"
3125 do
3126   test "x$ac_site_file" = xNONE && continue
3127   if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
3128     { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
3129 $as_echo "$as_me: loading site script $ac_site_file" >&6;}
3130     sed 's/^/| /' "$ac_site_file" >&5
3131     . "$ac_site_file" \
3132       || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3133 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3134 as_fn_error $? "failed to load site script $ac_site_file
3135 See \`config.log' for more details" "$LINENO" 5; }
3136   fi
3137 done
3138 
3139 if test -r "$cache_file"; then
3140   # Some versions of bash will fail to source /dev/null (special files
3141   # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
3142   if test /dev/null != "$cache_file" && test -f "$cache_file"; then
3143     { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
3144 $as_echo "$as_me: loading cache $cache_file" >&6;}
3145     case $cache_file in
3146       [\\/]* | ?:[\\/]* ) . "$cache_file";;
3147       *)                      . "./$cache_file";;
3148     esac
3149   fi
3150 else
3151   { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
3152 $as_echo "$as_me: creating cache $cache_file" >&6;}
3153   >$cache_file
3154 fi
3155 
3156 # Check that the precious variables saved in the cache have kept the same
3157 # value.
3158 ac_cache_corrupted=false
3159 for ac_var in $ac_precious_vars; do
3160   eval ac_old_set=\$ac_cv_env_${ac_var}_set
3161   eval ac_new_set=\$ac_env_${ac_var}_set
3162   eval ac_old_val=\$ac_cv_env_${ac_var}_value
3163   eval ac_new_val=\$ac_env_${ac_var}_value
3164   case $ac_old_set,$ac_new_set in
3165     set,)
3166       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
3167 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
3168       ac_cache_corrupted=: ;;
3169     ,set)
3170       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
3171 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
3172       ac_cache_corrupted=: ;;
3173     ,);;
3174     *)
3175       if test "x$ac_old_val" != "x$ac_new_val"; then
3176         # differences in whitespace do not lead to failure.
3177         ac_old_val_w=`echo x $ac_old_val`
3178         ac_new_val_w=`echo x $ac_new_val`
3179         if test "$ac_old_val_w" != "$ac_new_val_w"; then
3180           { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
3181 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
3182           ac_cache_corrupted=:
3183         else
3184           { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
3185 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
3186           eval $ac_var=\$ac_old_val
3187         fi
3188         { $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
3189 $as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
3190         { $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
3191 $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
3192       fi;;
3193   esac
3194   # Pass precious variables to config.status.
3195   if test "$ac_new_set" = set; then
3196     case $ac_new_val in
3197     *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
3198     *) ac_arg=$ac_var=$ac_new_val ;;
3199     esac
3200     case " $ac_configure_args " in
3201       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
3202       *) as_fn_append ac_configure_args " '$ac_arg'" ;;
3203     esac
3204   fi
3205 done
3206 if $ac_cache_corrupted; then
3207   { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3208 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3209   { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
3210 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
3211   as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
3212 fi
3213 ## -------------------- ##
3214 ## Main body of script. ##
3215 ## -------------------- ##
3216 
3217 ac_ext=c
3218 ac_cpp='$CPP $CPPFLAGS'
3219 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3220 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3221 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3222 
3223 
3224 
3225 ac_aux_dir=
3226 for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
3227   if test -f "$ac_dir/install-sh"; then
3228     ac_aux_dir=$ac_dir
3229     ac_install_sh="$ac_aux_dir/install-sh -c"
3230     break
3231   elif test -f "$ac_dir/install.sh"; then
3232     ac_aux_dir=$ac_dir
3233     ac_install_sh="$ac_aux_dir/install.sh -c"
3234     break
3235   elif test -f "$ac_dir/shtool"; then
3236     ac_aux_dir=$ac_dir
3237     ac_install_sh="$ac_aux_dir/shtool install -c"
3238     break
3239   fi
3240 done
3241 if test -z "$ac_aux_dir"; then
3242   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
3243 fi
3244 
3245 # These three variables are undocumented and unsupported,
3246 # and are intended to be withdrawn in a future Autoconf release.
3247 # They can cause serious problems if a builder's source tree is in a directory
3248 # whose full name contains unusual characters.
3249 ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
3250 ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
3251 ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
3252 
3253 
3254 # pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
3255 
3256 #
3257 # Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3258 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3259 #
3260 # This code is free software; you can redistribute it and/or modify it
3261 # under the terms of the GNU General Public License version 2 only, as
3262 # published by the Free Software Foundation.  Oracle designates this
3263 # particular file as subject to the "Classpath" exception as provided
3264 # by Oracle in the LICENSE file that accompanied this code.
3265 #
3266 # This code is distributed in the hope that it will be useful, but WITHOUT
3267 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3268 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3269 # version 2 for more details (a copy is included in the LICENSE file that
3270 # accompanied this code).
3271 #
3272 # You should have received a copy of the GNU General Public License version
3273 # 2 along with this work; if not, write to the Free Software Foundation,
3274 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3275 #
3276 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3277 # or visit www.oracle.com if you need additional information or have any
3278 # questions.
3279 #
3280 
3281 #
3282 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
3283 #
3284 # This program is free software; you can redistribute it and/or modify
3285 # it under the terms of the GNU General Public License as published by
3286 # the Free Software Foundation; either version 2 of the License, or
3287 # (at your option) any later version.
3288 #
3289 # This program is distributed in the hope that it will be useful, but
3290 # WITHOUT ANY WARRANTY; without even the implied warranty of
3291 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3292 # General Public License for more details.
3293 #
3294 # You should have received a copy of the GNU General Public License
3295 # along with this program; if not, write to the Free Software
3296 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3297 #
3298 # As a special exception to the GNU General Public License, if you
3299 # distribute this file as part of a program that contains a
3300 # configuration script generated by Autoconf, you may include it under
3301 # the same distribution terms that you use for the rest of that program.
3302 
3303 # PKG_PROG_PKG_CONFIG([MIN-VERSION])
3304 # ----------------------------------
3305 # PKG_PROG_PKG_CONFIG
3306 
3307 # PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
3308 #
3309 # Check to see whether a particular set of modules exists.  Similar
3310 # to PKG_CHECK_MODULES(), but does not set variables or print errors.
3311 #
3312 #
3313 # Similar to PKG_CHECK_MODULES, make sure that the first instance of
3314 # this or PKG_CHECK_MODULES is called, or make sure to call
3315 # PKG_CHECK_EXISTS manually
3316 # --------------------------------------------------------------
3317 
3318 
3319 
3320 # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
3321 # ---------------------------------------------
3322 # _PKG_CONFIG
3323 
3324 # _PKG_SHORT_ERRORS_SUPPORTED
3325 # -----------------------------
3326 # _PKG_SHORT_ERRORS_SUPPORTED
3327 
3328 
3329 # PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
3330 # [ACTION-IF-NOT-FOUND])
3331 #
3332 #
3333 # Note that if there is a possibility the first call to
3334 # PKG_CHECK_MODULES might not happen, you should be sure to include an
3335 # explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
3336 #
3337 #
3338 # --------------------------------------------------------------
3339 # PKG_CHECK_MODULES
3340 
3341 
3342 # Include these first...
3343 #
3344 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3345 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3346 #
3347 # This code is free software; you can redistribute it and/or modify it
3348 # under the terms of the GNU General Public License version 2 only, as
3349 # published by the Free Software Foundation.  Oracle designates this
3350 # particular file as subject to the "Classpath" exception as provided
3351 # by Oracle in the LICENSE file that accompanied this code.
3352 #
3353 # This code is distributed in the hope that it will be useful, but WITHOUT
3354 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3355 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3356 # version 2 for more details (a copy is included in the LICENSE file that
3357 # accompanied this code).
3358 #
3359 # You should have received a copy of the GNU General Public License version
3360 # 2 along with this work; if not, write to the Free Software Foundation,
3361 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3362 #
3363 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3364 # or visit www.oracle.com if you need additional information or have any
3365 # questions.
3366 #
3367 
3368 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3369 # If so, then append $1 to $2 \
3370 # Also set JVM_ARG_OK to true/false depending on outcome.
3371 
3372 
3373 # Appends a string to a path variable, only adding the : when needed.
3374 
3375 
3376 # Prepends a string to a path variable, only adding the : when needed.
3377 
3378 
3379 # This will make sure the given variable points to a full and proper
3380 # path. This means:
3381 # 1) There will be no spaces in the path. On unix platforms,
3382 #    spaces in the path will result in an error. On Windows,
3383 #    the path will be rewritten using short-style to be space-free.
3384 # 2) The path will be absolute, and it will be in unix-style (on
3385 #     cygwin).
3386 # $1: The name of the variable to fix
3387 
3388 
3389 # This will make sure the given variable points to a executable
3390 # with a full and proper path. This means:
3391 # 1) There will be no spaces in the path. On unix platforms,
3392 #    spaces in the path will result in an error. On Windows,
3393 #    the path will be rewritten using short-style to be space-free.
3394 # 2) The path will be absolute, and it will be in unix-style (on
3395 #     cygwin).
3396 # Any arguments given to the executable is preserved.
3397 # If the input variable does not have a directory specification, then
3398 # it need to be in the PATH.
3399 # $1: The name of the variable to fix
3400 
3401 
3402 
3403 
3404 # Register a --with argument but mark it as deprecated
3405 # $1: The name of the with argument to deprecate, not including --with-
3406 
3407 
3408 # Register a --enable argument but mark it as deprecated
3409 # $1: The name of the with argument to deprecate, not including --enable-
3410 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3411 
3412 
3413 
3414 
3415 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3416 # $1: variable to check
3417 
3418 
3419 # Check that there are no unprocessed overridden variables left.
3420 # If so, they are an incorrect argument and we will exit with an error.
3421 
3422 
3423 # Setup a tool for the given variable. If correctly specified by the user,
3424 # use that value, otherwise search for the tool using the supplied code snippet.
3425 # $1: variable to set
3426 # $2: code snippet to call to look for the tool
3427 
3428 
3429 # Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
3430 # $1: variable to set
3431 # $2: executable name (or list of names) to look for
3432 
3433 
3434 # Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
3435 # $1: variable to set
3436 # $2: executable name (or list of names) to look for
3437 
3438 
3439 # Like BASIC_PATH_PROGS but fails if no tool was found.
3440 # $1: variable to set
3441 # $2: executable name (or list of names) to look for
3442 
3443 
3444 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3445 # $1: variable to set
3446 # $2: autoconf macro to call to look for the special tool
3447 
3448 
3449 # Setup the most fundamental tools that relies on not much else to set up,
3450 # but is used by much of the early bootstrap code.
3451 
3452 
3453 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3454 
3455 
3456 
3457 
3458 
3459 
3460 
3461 
3462 
3463 #%%% Simple tools %%%
3464 
3465 # Check if we have found a usable version of make
3466 # $1: the path to a potential make binary (or empty)
3467 # $2: the description on how we found this
3468 
3469 
3470 
3471 
3472 # Goes looking for a usable version of GNU make.
3473 
3474 
3475 
3476 
3477 
3478 
3479 # Check if build directory is on local disk. If not possible to determine,
3480 # we prefer to claim it's local.
3481 # Argument 1: directory to test
3482 # Argument 2: what to do if it is on local disk
3483 # Argument 3: what to do otherwise (remote disk or failure)
3484 
3485 
3486 # Check that source files have basic read permissions set. This might
3487 # not be the case in cygwin in certain conditions.
3488 
3489 
3490 
3491 
3492 # Check for support for specific options in bash
3493 
3494 
3495 #
3496 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3497 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3498 #
3499 # This code is free software; you can redistribute it and/or modify it
3500 # under the terms of the GNU General Public License version 2 only, as
3501 # published by the Free Software Foundation.  Oracle designates this
3502 # particular file as subject to the "Classpath" exception as provided
3503 # by Oracle in the LICENSE file that accompanied this code.
3504 #
3505 # This code is distributed in the hope that it will be useful, but WITHOUT
3506 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3507 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3508 # version 2 for more details (a copy is included in the LICENSE file that
3509 # accompanied this code).
3510 #
3511 # You should have received a copy of the GNU General Public License version
3512 # 2 along with this work; if not, write to the Free Software Foundation,
3513 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3514 #
3515 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3516 # or visit www.oracle.com if you need additional information or have any
3517 # questions.
3518 #
3519 
3520 
3521 
3522 
3523 
3524 # Helper function which possibly converts a path using DOS-style short mode.
3525 # If so, the updated path is stored in $new_path.
3526 # $1: The path to check
3527 
3528 
3529 # Helper function which possibly converts a path using DOS-style short mode.
3530 # If so, the updated path is stored in $new_path.
3531 # $1: The path to check
3532 
3533 
3534 # FIXME: The BASIC_FIXUP_*_CYGWIN/MSYS is most likely too convoluted
3535 # and could probably be heavily simplified. However, all changes in this
3536 # area tend to need lot of testing in different scenarios, and in lack of
3537 # proper unit testing, cleaning this up has not been deemed worth the effort
3538 # at the moment.
3539 
3540 
3541 
3542 
3543 
3544 
3545 
3546 
3547 
3548 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3549 
3550 
3551 
3552 
3553 #
3554 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3555 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3556 #
3557 # This code is free software; you can redistribute it and/or modify it
3558 # under the terms of the GNU General Public License version 2 only, as
3559 # published by the Free Software Foundation.  Oracle designates this
3560 # particular file as subject to the "Classpath" exception as provided
3561 # by Oracle in the LICENSE file that accompanied this code.
3562 #
3563 # This code is distributed in the hope that it will be useful, but WITHOUT
3564 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3565 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3566 # version 2 for more details (a copy is included in the LICENSE file that
3567 # accompanied this code).
3568 #
3569 # You should have received a copy of the GNU General Public License version
3570 # 2 along with this work; if not, write to the Free Software Foundation,
3571 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3572 #
3573 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3574 # or visit www.oracle.com if you need additional information or have any
3575 # questions.
3576 #
3577 
3578 
3579 
3580 
3581 
3582 
3583 
3584 
3585 
3586 
3587 
3588 # ... then the rest
3589 #
3590 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3591 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3592 #
3593 # This code is free software; you can redistribute it and/or modify it
3594 # under the terms of the GNU General Public License version 2 only, as
3595 # published by the Free Software Foundation.  Oracle designates this
3596 # particular file as subject to the "Classpath" exception as provided
3597 # by Oracle in the LICENSE file that accompanied this code.
3598 #
3599 # This code is distributed in the hope that it will be useful, but WITHOUT
3600 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3601 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3602 # version 2 for more details (a copy is included in the LICENSE file that
3603 # accompanied this code).
3604 #
3605 # You should have received a copy of the GNU General Public License version
3606 # 2 along with this work; if not, write to the Free Software Foundation,
3607 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3608 #
3609 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3610 # or visit www.oracle.com if you need additional information or have any
3611 # questions.
3612 #
3613 
3614 ########################################################################
3615 # This file handles detection of the Boot JDK. The Boot JDK detection
3616 # process has been developed as a response to solve a complex real-world
3617 # problem. Initially, it was simple, but it has grown as platform after
3618 # platform, idiosyncracy after idiosyncracy has been supported.
3619 #
3620 # The basic idea is this:
3621 # 1) You need an acceptable *) JDK to use as a Boot JDK
3622 # 2) There are several ways to locate a JDK, that are mostly platform
3623 #    dependent **)
3624 # 3) You can have multiple JDKs installed
3625 # 4) If possible, configure should try to dig out an acceptable JDK
3626 #    automatically, without having to resort to command-line options
3627 #
3628 # *)  acceptable means e.g. JDK7 for building JDK8, a complete JDK (with
3629 #     javac) and not a JRE, etc.
3630 #
3631 # **) On Windows we typically use a well-known path.
3632 #     On MacOSX we typically use the tool java_home.
3633 #     On Linux we typically find javac in the $PATH, and then follow a
3634 #     chain of symlinks that often ends up in a real JDK.
3635 #
3636 # This leads to the code where we check in different ways to locate a
3637 # JDK, and if one is found, check if it is acceptable. If not, we print
3638 # our reasons for rejecting it (useful when debugging non-working
3639 # configure situations) and continue checking the next one.
3640 ########################################################################
3641 
3642 # Execute the check given as argument, and verify the result
3643 # If the Boot JDK was previously found, do nothing
3644 # $1 A command line (typically autoconf macro) to execute
3645 
3646 
3647 # Test: Is bootjdk explicitely set by command line arguments?
3648 
3649 
3650 # Test: Is bootjdk available from builddeps?
3651 
3652 
3653 # Test: Is $JAVA_HOME set?
3654 
3655 
3656 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
3657 
3658 
3659 # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
3660 # $1: Argument to the java_home binary (optional)
3661 
3662 
3663 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
3664 
3665 
3666 # Look for a jdk in the given path. If there are multiple, try to select the newest.
3667 # If found, set BOOT_JDK and BOOT_JDK_FOUND.
3668 # $1 = Path to directory containing jdk installations.
3669 # $2 = String to append to the found JDK directory to get the proper JDK home
3670 
3671 
3672 # Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
3673 # environmental variable as base for where to look.
3674 # $1 Name of an environmal variable, assumed to point to the Program Files directory.
3675 
3676 
3677 # Test: Is there a JDK installed in default, well-known locations?
3678 
3679 
3680 # Check that a command-line tool in the Boot JDK is correct
3681 # $1 = name of variable to assign
3682 # $2 = name of binary
3683 
3684 
3685 ###############################################################################
3686 #
3687 # We need a Boot JDK to bootstrap the build.
3688 #
3689 
3690 
3691 
3692 
3693 
3694 #
3695 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3696 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3697 #
3698 # This code is free software; you can redistribute it and/or modify it
3699 # under the terms of the GNU General Public License version 2 only, as
3700 # published by the Free Software Foundation.  Oracle designates this
3701 # particular file as subject to the "Classpath" exception as provided
3702 # by Oracle in the LICENSE file that accompanied this code.
3703 #
3704 # This code is distributed in the hope that it will be useful, but WITHOUT
3705 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3706 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3707 # version 2 for more details (a copy is included in the LICENSE file that
3708 # accompanied this code).
3709 #
3710 # You should have received a copy of the GNU General Public License version
3711 # 2 along with this work; if not, write to the Free Software Foundation,
3712 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3713 #
3714 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3715 # or visit www.oracle.com if you need additional information or have any
3716 # questions.
3717 #
3718 
3719 
3720 
3721 
3722 
3723 
3724 
3725 
3726 
3727 
3728 
3729 
3730 
3731 
3732 
3733 
3734 
3735 
3736 
3737 
3738 #
3739 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3740 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3741 #
3742 # This code is free software; you can redistribute it and/or modify it
3743 # under the terms of the GNU General Public License version 2 only, as
3744 # published by the Free Software Foundation.  Oracle designates this
3745 # particular file as subject to the "Classpath" exception as provided
3746 # by Oracle in the LICENSE file that accompanied this code.
3747 #
3748 # This code is distributed in the hope that it will be useful, but WITHOUT
3749 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3750 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3751 # version 2 for more details (a copy is included in the LICENSE file that
3752 # accompanied this code).
3753 #
3754 # You should have received a copy of the GNU General Public License version
3755 # 2 along with this work; if not, write to the Free Software Foundation,
3756 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3757 #
3758 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3759 # or visit www.oracle.com if you need additional information or have any
3760 # questions.
3761 #
3762 
3763 
3764 
3765 
3766 
3767 # Documentation on common flags used for solstudio in HIGHEST.
3768 #
3769 # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
3770 #          done with care, there are some assumptions below that need to
3771 #          be understood about the use of pointers, and IEEE behavior.
3772 #
3773 # -fns: Use non-standard floating point mode (not IEEE 754)
3774 # -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)
3775 # -fsingle: Use single precision floating point with 'float'
3776 # -xalias_level=basic: Assume memory references via basic pointer types do not alias
3777 #   (Source with excessing pointer casting and data access with mixed
3778 #    pointer types are not recommended)
3779 # -xbuiltin=%all: Use intrinsic or inline versions for math/std functions
3780 #   (If you expect perfect errno behavior, do not use this)
3781 # -xdepend: Loop data dependency optimizations (need -xO3 or higher)
3782 # -xrestrict: Pointer parameters to functions do not overlap
3783 #   (Similar to -xalias_level=basic usage, but less obvious sometimes.
3784 #    If you pass in multiple pointers to the same data, do not use this)
3785 # -xlibmil: Inline some library routines
3786 #   (If you expect perfect errno behavior, do not use this)
3787 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
3788 #   (If you expect perfect errno behavior, do not use this)
3789 #  Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
3790 
3791     # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
3792     # Bug?
3793     #if test "x$OPENJDK_TARGET_CPU" = xsparc; then
3794     #  CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
3795     #  CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
3796     #fi
3797 
3798 
3799 
3800 
3801 
3802 # FLAGS_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3803 #                                   [RUN-IF-FALSE])
3804 # ------------------------------------------------------------
3805 # Check that the c and c++ compilers support an argument
3806 
3807 
3808 # FLAGS_LINKER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3809 #                                    [RUN-IF-FALSE])
3810 # ------------------------------------------------------------
3811 # Check that the linker support an argument
3812 
3813 
3814 
3815 
3816 #
3817 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3818 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3819 #
3820 # This code is free software; you can redistribute it and/or modify it
3821 # under the terms of the GNU General Public License version 2 only, as
3822 # published by the Free Software Foundation.  Oracle designates this
3823 # particular file as subject to the "Classpath" exception as provided
3824 # by Oracle in the LICENSE file that accompanied this code.
3825 #
3826 # This code is distributed in the hope that it will be useful, but WITHOUT
3827 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3828 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3829 # version 2 for more details (a copy is included in the LICENSE file that
3830 # accompanied this code).
3831 #
3832 # You should have received a copy of the GNU General Public License version
3833 # 2 along with this work; if not, write to the Free Software Foundation,
3834 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3835 #
3836 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3837 # or visit www.oracle.com if you need additional information or have any
3838 # questions.
3839 #
3840 
3841 
3842 
3843 
3844 
3845 cygwin_help() {
3846   case $1 in
3847     unzip)
3848       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P unzip )"
3849       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3850       ;;
3851     zip)
3852       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P zip )"
3853       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3854       ;;
3855     make)
3856       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P make )"
3857       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3858       ;;
3859     freetype)
3860       HELP_MSG="
3861 The freetype library can now be build during the configure process.
3862 Download the freetype sources and unpack them into an arbitrary directory:
3863 
3864 wget http://download.savannah.gnu.org/releases/freetype/freetype-2.5.3.tar.gz
3865 tar -xzf freetype-2.5.3.tar.gz
3866 
3867 Then run configure with '--with-freetype-src=<freetype_src>'. This will
3868 automatically build the freetype library into '<freetype_src>/lib64' for 64-bit
3869 builds or into '<freetype_src>/lib32' for 32-bit builds.
3870 Afterwards you can always use '--with-freetype-include=<freetype_src>/include'
3871 and '--with-freetype-lib=<freetype_src>/lib32|64' for other builds."
3872       ;;
3873   esac
3874 }
3875 
3876 msys_help() {
3877   PKGHANDLER_COMMAND=""
3878 }
3879 
3880 apt_help() {
3881   case $1 in
3882     devkit)
3883       PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;;
3884     openjdk)
3885       PKGHANDLER_COMMAND="sudo apt-get install openjdk-7-jdk" ;;
3886     alsa)
3887       PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;;
3888     cups)
3889       PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;;
3890     freetype)
3891       PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;;
3892     pulse)
3893       PKGHANDLER_COMMAND="sudo apt-get install libpulse-dev" ;;
3894     x11)
3895       PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
3896     ccache)
3897       PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
3898   esac
3899 }
3900 
3901 yum_help() {
3902   case $1 in
3903     devkit)
3904       PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;;
3905     openjdk)
3906       PKGHANDLER_COMMAND="sudo yum install java-1.7.0-openjdk" ;;
3907     alsa)
3908       PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;;
3909     cups)
3910       PKGHANDLER_COMMAND="sudo yum install cups-devel" ;;
3911     freetype)
3912       PKGHANDLER_COMMAND="sudo yum install freetype-devel" ;;
3913     pulse)
3914       PKGHANDLER_COMMAND="sudo yum install pulseaudio-libs-devel" ;;
3915     x11)
3916       PKGHANDLER_COMMAND="sudo yum install libXtst-devel libXt-devel libXrender-devel libXi-devel" ;;
3917     ccache)
3918       PKGHANDLER_COMMAND="sudo yum install ccache" ;;
3919   esac
3920 }
3921 
3922 port_help() {
3923   PKGHANDLER_COMMAND=""
3924 }
3925 
3926 pkgutil_help() {
3927   PKGHANDLER_COMMAND=""
3928 }
3929 
3930 pkgadd_help() {
3931   PKGHANDLER_COMMAND=""
3932 }
3933 
3934 # This function will check if we're called from the "configure" wrapper while
3935 # printing --help. If so, we will print out additional information that can
3936 # only be extracted within the autoconf script, and then exit. This must be
3937 # called at the very beginning in configure.ac.
3938 
3939 
3940 
3941 
3942 
3943 
3944 #
3945 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3946 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3947 #
3948 # This code is free software; you can redistribute it and/or modify it
3949 # under the terms of the GNU General Public License version 2 only, as
3950 # published by the Free Software Foundation.  Oracle designates this
3951 # particular file as subject to the "Classpath" exception as provided
3952 # by Oracle in the LICENSE file that accompanied this code.
3953 #
3954 # This code is distributed in the hope that it will be useful, but WITHOUT
3955 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3956 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3957 # version 2 for more details (a copy is included in the LICENSE file that
3958 # accompanied this code).
3959 #
3960 # You should have received a copy of the GNU General Public License version
3961 # 2 along with this work; if not, write to the Free Software Foundation,
3962 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3963 #
3964 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3965 # or visit www.oracle.com if you need additional information or have any
3966 # questions.
3967 #
3968 
3969 
3970 
3971 
3972 
3973 
3974 
3975 
3976 
3977 
3978 ###############################################################################
3979 #
3980 # Should we build only OpenJDK even if closed sources are present?
3981 #
3982 
3983 
3984 
3985 
3986 ###############################################################################
3987 #
3988 # Setup version numbers
3989 #
3990 
3991 
3992 
3993 
3994 
3995 
3996 #
3997 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3998 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3999 #
4000 # This code is free software; you can redistribute it and/or modify it
4001 # under the terms of the GNU General Public License version 2 only, as
4002 # published by the Free Software Foundation.  Oracle designates this
4003 # particular file as subject to the "Classpath" exception as provided
4004 # by Oracle in the LICENSE file that accompanied this code.
4005 #
4006 # This code is distributed in the hope that it will be useful, but WITHOUT
4007 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4008 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4009 # version 2 for more details (a copy is included in the LICENSE file that
4010 # accompanied this code).
4011 #
4012 # You should have received a copy of the GNU General Public License version
4013 # 2 along with this work; if not, write to the Free Software Foundation,
4014 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4015 #
4016 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4017 # or visit www.oracle.com if you need additional information or have any
4018 # questions.
4019 #
4020 
4021 
4022 
4023 
4024 
4025 
4026 
4027 
4028 
4029 
4030 
4031 
4032 
4033 
4034 
4035 
4036 
4037 
4038 
4039 
4040 
4041 #
4042 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4043 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4044 #
4045 # This code is free software; you can redistribute it and/or modify it
4046 # under the terms of the GNU General Public License version 2 only, as
4047 # published by the Free Software Foundation.  Oracle designates this
4048 # particular file as subject to the "Classpath" exception as provided
4049 # by Oracle in the LICENSE file that accompanied this code.
4050 #
4051 # This code is distributed in the hope that it will be useful, but WITHOUT
4052 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4053 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4054 # version 2 for more details (a copy is included in the LICENSE file that
4055 # accompanied this code).
4056 #
4057 # You should have received a copy of the GNU General Public License version
4058 # 2 along with this work; if not, write to the Free Software Foundation,
4059 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4060 #
4061 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4062 # or visit www.oracle.com if you need additional information or have any
4063 # questions.
4064 #
4065 
4066 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4067 # Converts autoconf style CPU name to OpenJDK style, into
4068 # VAR_CPU, VAR_CPU_ARCH, VAR_CPU_BITS and VAR_CPU_ENDIAN.
4069 
4070 
4071 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4072 # Converts autoconf style OS name to OpenJDK style, into
4073 # VAR_OS, VAR_OS_TYPE and VAR_OS_ENV.
4074 
4075 
4076 # Expects $host_os $host_cpu $build_os and $build_cpu
4077 # and $with_target_bits to have been setup!
4078 #
4079 # Translate the standard triplet(quadruplet) definition
4080 # of the target/build system into OPENJDK_TARGET_OS, OPENJDK_TARGET_CPU,
4081 # OPENJDK_BUILD_OS, etc.
4082 
4083 
4084 # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
4085 # accordingly. Must be done after setting up build and target system, but before
4086 # doing anything else with these values.
4087 
4088 
4089 # Setup the legacy variables, for controlling the old makefiles.
4090 #
4091 
4092 
4093 
4094 
4095 #%%% Build and target systems %%%
4096 
4097 
4098 
4099 
4100 # Support macro for PLATFORM_SETUP_OPENJDK_TARGET_BITS.
4101 # Add -mX to various FLAGS variables.
4102 
4103 
4104 
4105 
4106 
4107 
4108 #
4109 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4110 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4111 #
4112 # This code is free software; you can redistribute it and/or modify it
4113 # under the terms of the GNU General Public License version 2 only, as
4114 # published by the Free Software Foundation.  Oracle designates this
4115 # particular file as subject to the "Classpath" exception as provided
4116 # by Oracle in the LICENSE file that accompanied this code.
4117 #
4118 # This code is distributed in the hope that it will be useful, but WITHOUT
4119 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4120 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4121 # version 2 for more details (a copy is included in the LICENSE file that
4122 # accompanied this code).
4123 #
4124 # You should have received a copy of the GNU General Public License version
4125 # 2 along with this work; if not, write to the Free Software Foundation,
4126 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4127 #
4128 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4129 # or visit www.oracle.com if you need additional information or have any
4130 # questions.
4131 #
4132 
4133 
4134 
4135 
4136 
4137 
4138 
4139 
4140 #
4141 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4142 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4143 #
4144 # This code is free software; you can redistribute it and/or modify it
4145 # under the terms of the GNU General Public License version 2 only, as
4146 # published by the Free Software Foundation.  Oracle designates this
4147 # particular file as subject to the "Classpath" exception as provided
4148 # by Oracle in the LICENSE file that accompanied this code.
4149 #
4150 # This code is distributed in the hope that it will be useful, but WITHOUT
4151 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4152 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4153 # version 2 for more details (a copy is included in the LICENSE file that
4154 # accompanied this code).
4155 #
4156 # You should have received a copy of the GNU General Public License version
4157 # 2 along with this work; if not, write to the Free Software Foundation,
4158 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4159 #
4160 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4161 # or visit www.oracle.com if you need additional information or have any
4162 # questions.
4163 #
4164 
4165 ########################################################################
4166 # This file is responsible for detecting, verifying and setting up the
4167 # toolchain, i.e. the compiler, linker and related utilities. It will setup
4168 # proper paths to the binaries, but it will not setup any flags.
4169 #
4170 # The binaries used is determined by the toolchain type, which is the family of
4171 # compilers and related tools that are used.
4172 ########################################################################
4173 
4174 
4175 # All valid toolchains, regardless of platform (used by help.m4)
4176 VALID_TOOLCHAINS_all="gcc clang solstudio xlc microsoft"
4177 
4178 # These toolchains are valid on different platforms
4179 VALID_TOOLCHAINS_linux="gcc clang"
4180 VALID_TOOLCHAINS_solaris="solstudio"
4181 VALID_TOOLCHAINS_macosx="gcc clang"
4182 VALID_TOOLCHAINS_aix="xlc"
4183 VALID_TOOLCHAINS_windows="microsoft"
4184 
4185 # Toolchain descriptions
4186 TOOLCHAIN_DESCRIPTION_clang="clang/LLVM"
4187 TOOLCHAIN_DESCRIPTION_gcc="GNU Compiler Collection"
4188 TOOLCHAIN_DESCRIPTION_microsoft="Microsoft Visual Studio"
4189 TOOLCHAIN_DESCRIPTION_solstudio="Oracle Solaris Studio"
4190 TOOLCHAIN_DESCRIPTION_xlc="IBM XL C/C++"
4191 
4192 # Setup a number of variables describing how native output files are
4193 # named on this platform/toolchain.
4194 
4195 
4196 # Determine which toolchain type to use, and make sure it is valid for this
4197 # platform. Setup various information about the selected toolchain.
4198 
4199 
4200 # Before we start detecting the toolchain executables, we might need some
4201 # special setup, e.g. additional paths etc.
4202 
4203 
4204 # Restore path, etc
4205 
4206 
4207 # Check if a compiler is of the toolchain type we expect, and save the version
4208 # information from it. If the compiler does not match the expected type,
4209 # this function will abort using AC_MSG_ERROR. If it matches, the version will
4210 # be stored in CC_VERSION_NUMBER/CXX_VERSION_NUMBER (as a dotted number), and
4211 # the full version string in CC_VERSION_STRING/CXX_VERSION_STRING.
4212 #
4213 # $1 = compiler to test (CC or CXX)
4214 # $2 = human readable name of compiler (C or C++)
4215 
4216 
4217 # Try to locate the given C or C++ compiler in the path, or otherwise.
4218 #
4219 # $1 = compiler to test (CC or CXX)
4220 # $2 = human readable name of compiler (C or C++)
4221 # $3 = list of compiler names to search for
4222 
4223 
4224 # Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
4225 # preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
4226 # archiver (AR). Verify that the compilers are correct according to the
4227 # toolchain type.
4228 
4229 
4230 # Setup additional tools that is considered a part of the toolchain, but not the
4231 # core part. Many of these are highly platform-specific and do not exist,
4232 # and/or are not needed on all platforms.
4233 
4234 
4235 # Setup the build tools (i.e, the compiler and linker used to build programs
4236 # that should be run on the build platform, not the target platform, as a build
4237 # helper). Since the non-cross-compile case uses the normal, target compilers
4238 # for this, we can only do this after these have been setup.
4239 
4240 
4241 # Setup legacy variables that are still needed as alternative ways to refer to
4242 # parts of the toolchain.
4243 
4244 
4245 # Do some additional checks on the detected tools.
4246 
4247 
4248 # Setup the JTReg Regression Test Harness.
4249 
4250 
4251 #
4252 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4253 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4254 #
4255 # This code is free software; you can redistribute it and/or modify it
4256 # under the terms of the GNU General Public License version 2 only, as
4257 # published by the Free Software Foundation.  Oracle designates this
4258 # particular file as subject to the "Classpath" exception as provided
4259 # by Oracle in the LICENSE file that accompanied this code.
4260 #
4261 # This code is distributed in the hope that it will be useful, but WITHOUT
4262 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4263 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4264 # version 2 for more details (a copy is included in the LICENSE file that
4265 # accompanied this code).
4266 #
4267 # You should have received a copy of the GNU General Public License version
4268 # 2 along with this work; if not, write to the Free Software Foundation,
4269 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4270 #
4271 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4272 # or visit www.oracle.com if you need additional information or have any
4273 # questions.
4274 #
4275 
4276 ################################################################################
4277 
4278 VALID_VS_VERSIONS="2010 2012 2013"
4279 
4280 VS_DESCRIPTION_2010="Microsoft Visual Studio 2010"
4281 VS_VERSION_INTERNAL_2010=100
4282 VS_MSVCR_2010=msvcr100.dll
4283 # We don't use msvcp on Visual Studio 2010
4284 #VS_MSVCP_2010=msvcp100.dll
4285 VS_ENVVAR_2010="VS100COMNTOOLS"
4286 VS_VS_INSTALLDIR_2010="Microsoft Visual Studio 10.0"
4287 VS_SDK_INSTALLDIR_2010="Microsoft SDKs/Windows/v7.1"
4288 VS_VS_PLATFORM_NAME_2010="v100"
4289 VS_SDK_PLATFORM_NAME_2010="Windows7.1SDK"
4290 
4291 VS_DESCRIPTION_2012="Microsoft Visual Studio 2012"
4292 VS_VERSION_INTERNAL_2012=110
4293 VS_MSVCR_2012=msvcr110.dll
4294 VS_MSVCP_2012=msvcp110.dll
4295 VS_ENVVAR_2012="VS110COMNTOOLS"
4296 VS_VS_INSTALLDIR_2012="Microsoft Visual Studio 11.0"
4297 VS_SDK_INSTALLDIR_2012=
4298 VS_VS_PLATFORM_NAME_2012="v110"
4299 VS_SDK_PLATFORM_NAME_2012=
4300 
4301 VS_DESCRIPTION_2013="Microsoft Visual Studio 2013"
4302 VS_VERSION_INTERNAL_2013=120
4303 VS_MSVCR_2013=msvcr120.dll
4304 VS_MSVCP_2013=msvcp120.dll
4305 VS_ENVVAR_2013="VS120COMNTOOLS"
4306 VS_VS_INSTALLDIR_2013="Microsoft Visual Studio 12.0"
4307 VS_SDK_INSTALLDIR_2013=
4308 VS_VS_PLATFORM_NAME_2013="v120"
4309 VS_SDK_PLATFORM_NAME_2013=
4310 
4311 ################################################################################
4312 
4313 
4314 
4315 ################################################################################
4316 
4317 
4318 
4319 ################################################################################
4320 # Finds the bat or cmd file in Visual Studio or the SDK that sets up a proper
4321 # build environment and assigns it to VS_ENV_CMD
4322 
4323 
4324 ################################################################################
4325 
4326 
4327 
4328 ################################################################################
4329 # Check if the VS env variables were setup prior to running configure.
4330 # If not, then find vcvarsall.bat and run it automatically, and integrate
4331 # the set env variables into the spec file.
4332 
4333 
4334 
4335 
4336 
4337 
4338 
4339 
4340 
4341 
4342 
4343 
4344 
4345 # This line needs to be here, verbatim, after all includes and the dummy hook
4346 # definitions. It is replaced with custom functionality when building
4347 # custom sources.
4348 #CUSTOM_AUTOCONF_INCLUDE
4349 
4350 # Do not change or remove the following line, it is needed for consistency checks:
4351 DATE_WHEN_GENERATED=1425462435
4352 
4353 ###############################################################################
4354 #
4355 # Initialization / Boot-strapping
4356 #
4357 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4358 # thus it jumps back and forth, each time gaining something needed later on.
4359 #
4360 ###############################################################################
4361 
4362 # If we are requested to print additional help, do that and then exit.
4363 # This must be the very first call.
4364 
4365   if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4366     $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4367     $PRINTF "Which are valid to use depends on the build platform.\n"
4368     for toolchain in $VALID_TOOLCHAINS_all; do
4369       # Use indirect variable referencing
4370       toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4371       TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
4372       $PRINTF "  %-10s  %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
4373     done
4374 
4375     # And now exit directly
4376     exit 0
4377   fi
4378 
4379 
4380 # Basic initialization that must happen first of all in the normal process.
4381 
4382   # Save the original command line. This is passed to us by the wrapper configure script.
4383 
4384   # Save the path variable before it gets changed
4385   ORIGINAL_PATH="$PATH"
4386 
4387   DATE_WHEN_CONFIGURED=`LANG=C date`
4388 
4389   { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
4390 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
4391   { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
4392 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
4393 
4394 
4395   # Start with tools that do not need have cross compilation support
4396   # and can be expected to be found in the default PATH. These tools are
4397   # used by configure. Nor are these tools expected to be found in the
4398   # devkit from the builddeps server either, since they are
4399   # needed to download the devkit.
4400 
4401   # First are all the simple required tools.
4402 
4403 
4404 
4405   # Publish this variable in the help.
4406 
4407 
4408   if test "x$BASENAME" = x; then
4409     # The variable is not set by user, try to locate tool using the code snippet
4410     for ac_prog in basename
4411 do
4412   # Extract the first word of "$ac_prog", so it can be a program name with args.
4413 set dummy $ac_prog; ac_word=$2
4414 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4415 $as_echo_n "checking for $ac_word... " >&6; }
4416 if ${ac_cv_path_BASENAME+:} false; then :
4417   $as_echo_n "(cached) " >&6
4418 else
4419   case $BASENAME in
4420   [\\/]* | ?:[\\/]*)
4421   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4422   ;;
4423   *)
4424   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4425 for as_dir in $PATH
4426 do
4427   IFS=$as_save_IFS
4428   test -z "$as_dir" && as_dir=.
4429     for ac_exec_ext in '' $ac_executable_extensions; do
4430   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4431     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4432     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4433     break 2
4434   fi
4435 done
4436   done
4437 IFS=$as_save_IFS
4438 
4439   ;;
4440 esac
4441 fi
4442 BASENAME=$ac_cv_path_BASENAME
4443 if test -n "$BASENAME"; then
4444   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4445 $as_echo "$BASENAME" >&6; }
4446 else
4447   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4448 $as_echo "no" >&6; }
4449 fi
4450 
4451 
4452   test -n "$BASENAME" && break
4453 done
4454 
4455   else
4456     # The variable is set, but is it from the command line or the environment?
4457 
4458     # Try to remove the string !BASENAME! from our list.
4459     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
4460     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4461       # If it failed, the variable was not from the command line. Ignore it,
4462       # but warn the user (except for BASH, which is always set by the calling BASH).
4463       if test "xBASENAME" != xBASH; then
4464         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
4465 $as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
4466       fi
4467       # Try to locate tool using the code snippet
4468       for ac_prog in basename
4469 do
4470   # Extract the first word of "$ac_prog", so it can be a program name with args.
4471 set dummy $ac_prog; ac_word=$2
4472 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4473 $as_echo_n "checking for $ac_word... " >&6; }
4474 if ${ac_cv_path_BASENAME+:} false; then :
4475   $as_echo_n "(cached) " >&6
4476 else
4477   case $BASENAME in
4478   [\\/]* | ?:[\\/]*)
4479   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4480   ;;
4481   *)
4482   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4483 for as_dir in $PATH
4484 do
4485   IFS=$as_save_IFS
4486   test -z "$as_dir" && as_dir=.
4487     for ac_exec_ext in '' $ac_executable_extensions; do
4488   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4489     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4490     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4491     break 2
4492   fi
4493 done
4494   done
4495 IFS=$as_save_IFS
4496 
4497   ;;
4498 esac
4499 fi
4500 BASENAME=$ac_cv_path_BASENAME
4501 if test -n "$BASENAME"; then
4502   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4503 $as_echo "$BASENAME" >&6; }
4504 else
4505   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4506 $as_echo "no" >&6; }
4507 fi
4508 
4509 
4510   test -n "$BASENAME" && break
4511 done
4512 
4513     else
4514       # If it succeeded, then it was overridden by the user. We will use it
4515       # for the tool.
4516 
4517       # First remove it from the list of overridden variables, so we can test
4518       # for unknown variables in the end.
4519       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4520 
4521       # Check if the provided tool contains a complete path.
4522       tool_specified="$BASENAME"
4523       tool_basename="${tool_specified##*/}"
4524       if test "x$tool_basename" = "x$tool_specified"; then
4525         # A command without a complete path is provided, search $PATH.
4526         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
4527 $as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
4528         # Extract the first word of "$tool_basename", so it can be a program name with args.
4529 set dummy $tool_basename; ac_word=$2
4530 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4531 $as_echo_n "checking for $ac_word... " >&6; }
4532 if ${ac_cv_path_BASENAME+:} false; then :
4533   $as_echo_n "(cached) " >&6
4534 else
4535   case $BASENAME in
4536   [\\/]* | ?:[\\/]*)
4537   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4538   ;;
4539   *)
4540   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4541 for as_dir in $PATH
4542 do
4543   IFS=$as_save_IFS
4544   test -z "$as_dir" && as_dir=.
4545     for ac_exec_ext in '' $ac_executable_extensions; do
4546   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4547     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4548     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4549     break 2
4550   fi
4551 done
4552   done
4553 IFS=$as_save_IFS
4554 
4555   ;;
4556 esac
4557 fi
4558 BASENAME=$ac_cv_path_BASENAME
4559 if test -n "$BASENAME"; then
4560   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4561 $as_echo "$BASENAME" >&6; }
4562 else
4563   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4564 $as_echo "no" >&6; }
4565 fi
4566 
4567 
4568         if test "x$BASENAME" = x; then
4569           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4570         fi
4571       else
4572         # Otherwise we believe it is a complete path. Use it as it is.
4573         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
4574 $as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
4575         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
4576 $as_echo_n "checking for BASENAME... " >&6; }
4577         if test ! -x "$tool_specified"; then
4578           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4579 $as_echo "not found" >&6; }
4580           as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
4581         fi
4582         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4583 $as_echo "$tool_specified" >&6; }
4584       fi
4585     fi
4586   fi
4587 
4588 
4589 
4590   if test "x$BASENAME" = x; then
4591     as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
4592   fi
4593 
4594 
4595 
4596 
4597 
4598   # Publish this variable in the help.
4599 
4600 
4601   if test "x$BASH" = x; then
4602     # The variable is not set by user, try to locate tool using the code snippet
4603     for ac_prog in bash
4604 do
4605   # Extract the first word of "$ac_prog", so it can be a program name with args.
4606 set dummy $ac_prog; ac_word=$2
4607 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4608 $as_echo_n "checking for $ac_word... " >&6; }
4609 if ${ac_cv_path_BASH+:} false; then :
4610   $as_echo_n "(cached) " >&6
4611 else
4612   case $BASH in
4613   [\\/]* | ?:[\\/]*)
4614   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4615   ;;
4616   *)
4617   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4618 for as_dir in $PATH
4619 do
4620   IFS=$as_save_IFS
4621   test -z "$as_dir" && as_dir=.
4622     for ac_exec_ext in '' $ac_executable_extensions; do
4623   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4624     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4625     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4626     break 2
4627   fi
4628 done
4629   done
4630 IFS=$as_save_IFS
4631 
4632   ;;
4633 esac
4634 fi
4635 BASH=$ac_cv_path_BASH
4636 if test -n "$BASH"; then
4637   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4638 $as_echo "$BASH" >&6; }
4639 else
4640   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4641 $as_echo "no" >&6; }
4642 fi
4643 
4644 
4645   test -n "$BASH" && break
4646 done
4647 
4648   else
4649     # The variable is set, but is it from the command line or the environment?
4650 
4651     # Try to remove the string !BASH! from our list.
4652     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
4653     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4654       # If it failed, the variable was not from the command line. Ignore it,
4655       # but warn the user (except for BASH, which is always set by the calling BASH).
4656       if test "xBASH" != xBASH; then
4657         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
4658 $as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
4659       fi
4660       # Try to locate tool using the code snippet
4661       for ac_prog in bash
4662 do
4663   # Extract the first word of "$ac_prog", so it can be a program name with args.
4664 set dummy $ac_prog; ac_word=$2
4665 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4666 $as_echo_n "checking for $ac_word... " >&6; }
4667 if ${ac_cv_path_BASH+:} false; then :
4668   $as_echo_n "(cached) " >&6
4669 else
4670   case $BASH in
4671   [\\/]* | ?:[\\/]*)
4672   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4673   ;;
4674   *)
4675   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4676 for as_dir in $PATH
4677 do
4678   IFS=$as_save_IFS
4679   test -z "$as_dir" && as_dir=.
4680     for ac_exec_ext in '' $ac_executable_extensions; do
4681   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4682     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4683     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4684     break 2
4685   fi
4686 done
4687   done
4688 IFS=$as_save_IFS
4689 
4690   ;;
4691 esac
4692 fi
4693 BASH=$ac_cv_path_BASH
4694 if test -n "$BASH"; then
4695   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4696 $as_echo "$BASH" >&6; }
4697 else
4698   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4699 $as_echo "no" >&6; }
4700 fi
4701 
4702 
4703   test -n "$BASH" && break
4704 done
4705 
4706     else
4707       # If it succeeded, then it was overridden by the user. We will use it
4708       # for the tool.
4709 
4710       # First remove it from the list of overridden variables, so we can test
4711       # for unknown variables in the end.
4712       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4713 
4714       # Check if the provided tool contains a complete path.
4715       tool_specified="$BASH"
4716       tool_basename="${tool_specified##*/}"
4717       if test "x$tool_basename" = "x$tool_specified"; then
4718         # A command without a complete path is provided, search $PATH.
4719         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
4720 $as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
4721         # Extract the first word of "$tool_basename", so it can be a program name with args.
4722 set dummy $tool_basename; ac_word=$2
4723 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4724 $as_echo_n "checking for $ac_word... " >&6; }
4725 if ${ac_cv_path_BASH+:} false; then :
4726   $as_echo_n "(cached) " >&6
4727 else
4728   case $BASH in
4729   [\\/]* | ?:[\\/]*)
4730   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4731   ;;
4732   *)
4733   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4734 for as_dir in $PATH
4735 do
4736   IFS=$as_save_IFS
4737   test -z "$as_dir" && as_dir=.
4738     for ac_exec_ext in '' $ac_executable_extensions; do
4739   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4740     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4741     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4742     break 2
4743   fi
4744 done
4745   done
4746 IFS=$as_save_IFS
4747 
4748   ;;
4749 esac
4750 fi
4751 BASH=$ac_cv_path_BASH
4752 if test -n "$BASH"; then
4753   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4754 $as_echo "$BASH" >&6; }
4755 else
4756   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4757 $as_echo "no" >&6; }
4758 fi
4759 
4760 
4761         if test "x$BASH" = x; then
4762           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4763         fi
4764       else
4765         # Otherwise we believe it is a complete path. Use it as it is.
4766         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
4767 $as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
4768         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
4769 $as_echo_n "checking for BASH... " >&6; }
4770         if test ! -x "$tool_specified"; then
4771           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4772 $as_echo "not found" >&6; }
4773           as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
4774         fi
4775         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4776 $as_echo "$tool_specified" >&6; }
4777       fi
4778     fi
4779   fi
4780 
4781 
4782 
4783   if test "x$BASH" = x; then
4784     as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
4785   fi
4786 
4787 
4788 
4789 
4790 
4791   # Publish this variable in the help.
4792 
4793 
4794   if test "x$CAT" = x; then
4795     # The variable is not set by user, try to locate tool using the code snippet
4796     for ac_prog in cat
4797 do
4798   # Extract the first word of "$ac_prog", so it can be a program name with args.
4799 set dummy $ac_prog; ac_word=$2
4800 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4801 $as_echo_n "checking for $ac_word... " >&6; }
4802 if ${ac_cv_path_CAT+:} false; then :
4803   $as_echo_n "(cached) " >&6
4804 else
4805   case $CAT in
4806   [\\/]* | ?:[\\/]*)
4807   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4808   ;;
4809   *)
4810   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4811 for as_dir in $PATH
4812 do
4813   IFS=$as_save_IFS
4814   test -z "$as_dir" && as_dir=.
4815     for ac_exec_ext in '' $ac_executable_extensions; do
4816   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4817     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4818     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4819     break 2
4820   fi
4821 done
4822   done
4823 IFS=$as_save_IFS
4824 
4825   ;;
4826 esac
4827 fi
4828 CAT=$ac_cv_path_CAT
4829 if test -n "$CAT"; then
4830   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4831 $as_echo "$CAT" >&6; }
4832 else
4833   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4834 $as_echo "no" >&6; }
4835 fi
4836 
4837 
4838   test -n "$CAT" && break
4839 done
4840 
4841   else
4842     # The variable is set, but is it from the command line or the environment?
4843 
4844     # Try to remove the string !CAT! from our list.
4845     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
4846     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4847       # If it failed, the variable was not from the command line. Ignore it,
4848       # but warn the user (except for BASH, which is always set by the calling BASH).
4849       if test "xCAT" != xBASH; then
4850         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
4851 $as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
4852       fi
4853       # Try to locate tool using the code snippet
4854       for ac_prog in cat
4855 do
4856   # Extract the first word of "$ac_prog", so it can be a program name with args.
4857 set dummy $ac_prog; ac_word=$2
4858 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4859 $as_echo_n "checking for $ac_word... " >&6; }
4860 if ${ac_cv_path_CAT+:} false; then :
4861   $as_echo_n "(cached) " >&6
4862 else
4863   case $CAT in
4864   [\\/]* | ?:[\\/]*)
4865   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4866   ;;
4867   *)
4868   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4869 for as_dir in $PATH
4870 do
4871   IFS=$as_save_IFS
4872   test -z "$as_dir" && as_dir=.
4873     for ac_exec_ext in '' $ac_executable_extensions; do
4874   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4875     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4876     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4877     break 2
4878   fi
4879 done
4880   done
4881 IFS=$as_save_IFS
4882 
4883   ;;
4884 esac
4885 fi
4886 CAT=$ac_cv_path_CAT
4887 if test -n "$CAT"; then
4888   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4889 $as_echo "$CAT" >&6; }
4890 else
4891   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4892 $as_echo "no" >&6; }
4893 fi
4894 
4895 
4896   test -n "$CAT" && break
4897 done
4898 
4899     else
4900       # If it succeeded, then it was overridden by the user. We will use it
4901       # for the tool.
4902 
4903       # First remove it from the list of overridden variables, so we can test
4904       # for unknown variables in the end.
4905       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4906 
4907       # Check if the provided tool contains a complete path.
4908       tool_specified="$CAT"
4909       tool_basename="${tool_specified##*/}"
4910       if test "x$tool_basename" = "x$tool_specified"; then
4911         # A command without a complete path is provided, search $PATH.
4912         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
4913 $as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
4914         # Extract the first word of "$tool_basename", so it can be a program name with args.
4915 set dummy $tool_basename; ac_word=$2
4916 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4917 $as_echo_n "checking for $ac_word... " >&6; }
4918 if ${ac_cv_path_CAT+:} false; then :
4919   $as_echo_n "(cached) " >&6
4920 else
4921   case $CAT in
4922   [\\/]* | ?:[\\/]*)
4923   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4924   ;;
4925   *)
4926   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4927 for as_dir in $PATH
4928 do
4929   IFS=$as_save_IFS
4930   test -z "$as_dir" && as_dir=.
4931     for ac_exec_ext in '' $ac_executable_extensions; do
4932   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4933     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4934     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4935     break 2
4936   fi
4937 done
4938   done
4939 IFS=$as_save_IFS
4940 
4941   ;;
4942 esac
4943 fi
4944 CAT=$ac_cv_path_CAT
4945 if test -n "$CAT"; then
4946   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4947 $as_echo "$CAT" >&6; }
4948 else
4949   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4950 $as_echo "no" >&6; }
4951 fi
4952 
4953 
4954         if test "x$CAT" = x; then
4955           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4956         fi
4957       else
4958         # Otherwise we believe it is a complete path. Use it as it is.
4959         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
4960 $as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
4961         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
4962 $as_echo_n "checking for CAT... " >&6; }
4963         if test ! -x "$tool_specified"; then
4964           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4965 $as_echo "not found" >&6; }
4966           as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
4967         fi
4968         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4969 $as_echo "$tool_specified" >&6; }
4970       fi
4971     fi
4972   fi
4973 
4974 
4975 
4976   if test "x$CAT" = x; then
4977     as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
4978   fi
4979 
4980 
4981 
4982 
4983 
4984   # Publish this variable in the help.
4985 
4986 
4987   if test "x$CHMOD" = x; then
4988     # The variable is not set by user, try to locate tool using the code snippet
4989     for ac_prog in chmod
4990 do
4991   # Extract the first word of "$ac_prog", so it can be a program name with args.
4992 set dummy $ac_prog; ac_word=$2
4993 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4994 $as_echo_n "checking for $ac_word... " >&6; }
4995 if ${ac_cv_path_CHMOD+:} false; then :
4996   $as_echo_n "(cached) " >&6
4997 else
4998   case $CHMOD in
4999   [\\/]* | ?:[\\/]*)
5000   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5001   ;;
5002   *)
5003   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5004 for as_dir in $PATH
5005 do
5006   IFS=$as_save_IFS
5007   test -z "$as_dir" && as_dir=.
5008     for ac_exec_ext in '' $ac_executable_extensions; do
5009   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5010     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5011     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5012     break 2
5013   fi
5014 done
5015   done
5016 IFS=$as_save_IFS
5017 
5018   ;;
5019 esac
5020 fi
5021 CHMOD=$ac_cv_path_CHMOD
5022 if test -n "$CHMOD"; then
5023   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5024 $as_echo "$CHMOD" >&6; }
5025 else
5026   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5027 $as_echo "no" >&6; }
5028 fi
5029 
5030 
5031   test -n "$CHMOD" && break
5032 done
5033 
5034   else
5035     # The variable is set, but is it from the command line or the environment?
5036 
5037     # Try to remove the string !CHMOD! from our list.
5038     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
5039     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5040       # If it failed, the variable was not from the command line. Ignore it,
5041       # but warn the user (except for BASH, which is always set by the calling BASH).
5042       if test "xCHMOD" != xBASH; then
5043         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
5044 $as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
5045       fi
5046       # Try to locate tool using the code snippet
5047       for ac_prog in chmod
5048 do
5049   # Extract the first word of "$ac_prog", so it can be a program name with args.
5050 set dummy $ac_prog; ac_word=$2
5051 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5052 $as_echo_n "checking for $ac_word... " >&6; }
5053 if ${ac_cv_path_CHMOD+:} false; then :
5054   $as_echo_n "(cached) " >&6
5055 else
5056   case $CHMOD in
5057   [\\/]* | ?:[\\/]*)
5058   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5059   ;;
5060   *)
5061   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5062 for as_dir in $PATH
5063 do
5064   IFS=$as_save_IFS
5065   test -z "$as_dir" && as_dir=.
5066     for ac_exec_ext in '' $ac_executable_extensions; do
5067   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5068     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5069     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5070     break 2
5071   fi
5072 done
5073   done
5074 IFS=$as_save_IFS
5075 
5076   ;;
5077 esac
5078 fi
5079 CHMOD=$ac_cv_path_CHMOD
5080 if test -n "$CHMOD"; then
5081   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5082 $as_echo "$CHMOD" >&6; }
5083 else
5084   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5085 $as_echo "no" >&6; }
5086 fi
5087 
5088 
5089   test -n "$CHMOD" && break
5090 done
5091 
5092     else
5093       # If it succeeded, then it was overridden by the user. We will use it
5094       # for the tool.
5095 
5096       # First remove it from the list of overridden variables, so we can test
5097       # for unknown variables in the end.
5098       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5099 
5100       # Check if the provided tool contains a complete path.
5101       tool_specified="$CHMOD"
5102       tool_basename="${tool_specified##*/}"
5103       if test "x$tool_basename" = "x$tool_specified"; then
5104         # A command without a complete path is provided, search $PATH.
5105         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
5106 $as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
5107         # Extract the first word of "$tool_basename", so it can be a program name with args.
5108 set dummy $tool_basename; ac_word=$2
5109 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5110 $as_echo_n "checking for $ac_word... " >&6; }
5111 if ${ac_cv_path_CHMOD+:} false; then :
5112   $as_echo_n "(cached) " >&6
5113 else
5114   case $CHMOD in
5115   [\\/]* | ?:[\\/]*)
5116   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5117   ;;
5118   *)
5119   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5120 for as_dir in $PATH
5121 do
5122   IFS=$as_save_IFS
5123   test -z "$as_dir" && as_dir=.
5124     for ac_exec_ext in '' $ac_executable_extensions; do
5125   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5126     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5127     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5128     break 2
5129   fi
5130 done
5131   done
5132 IFS=$as_save_IFS
5133 
5134   ;;
5135 esac
5136 fi
5137 CHMOD=$ac_cv_path_CHMOD
5138 if test -n "$CHMOD"; then
5139   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5140 $as_echo "$CHMOD" >&6; }
5141 else
5142   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5143 $as_echo "no" >&6; }
5144 fi
5145 
5146 
5147         if test "x$CHMOD" = x; then
5148           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5149         fi
5150       else
5151         # Otherwise we believe it is a complete path. Use it as it is.
5152         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
5153 $as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
5154         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5155 $as_echo_n "checking for CHMOD... " >&6; }
5156         if test ! -x "$tool_specified"; then
5157           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5158 $as_echo "not found" >&6; }
5159           as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
5160         fi
5161         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5162 $as_echo "$tool_specified" >&6; }
5163       fi
5164     fi
5165   fi
5166 
5167 
5168 
5169   if test "x$CHMOD" = x; then
5170     as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
5171   fi
5172 
5173 
5174 
5175 
5176 
5177   # Publish this variable in the help.
5178 
5179 
5180   if test "x$CMP" = x; then
5181     # The variable is not set by user, try to locate tool using the code snippet
5182     for ac_prog in cmp
5183 do
5184   # Extract the first word of "$ac_prog", so it can be a program name with args.
5185 set dummy $ac_prog; ac_word=$2
5186 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5187 $as_echo_n "checking for $ac_word... " >&6; }
5188 if ${ac_cv_path_CMP+:} false; then :
5189   $as_echo_n "(cached) " >&6
5190 else
5191   case $CMP in
5192   [\\/]* | ?:[\\/]*)
5193   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5194   ;;
5195   *)
5196   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5197 for as_dir in $PATH
5198 do
5199   IFS=$as_save_IFS
5200   test -z "$as_dir" && as_dir=.
5201     for ac_exec_ext in '' $ac_executable_extensions; do
5202   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5203     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5204     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5205     break 2
5206   fi
5207 done
5208   done
5209 IFS=$as_save_IFS
5210 
5211   ;;
5212 esac
5213 fi
5214 CMP=$ac_cv_path_CMP
5215 if test -n "$CMP"; then
5216   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5217 $as_echo "$CMP" >&6; }
5218 else
5219   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5220 $as_echo "no" >&6; }
5221 fi
5222 
5223 
5224   test -n "$CMP" && break
5225 done
5226 
5227   else
5228     # The variable is set, but is it from the command line or the environment?
5229 
5230     # Try to remove the string !CMP! from our list.
5231     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
5232     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5233       # If it failed, the variable was not from the command line. Ignore it,
5234       # but warn the user (except for BASH, which is always set by the calling BASH).
5235       if test "xCMP" != xBASH; then
5236         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
5237 $as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
5238       fi
5239       # Try to locate tool using the code snippet
5240       for ac_prog in cmp
5241 do
5242   # Extract the first word of "$ac_prog", so it can be a program name with args.
5243 set dummy $ac_prog; ac_word=$2
5244 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5245 $as_echo_n "checking for $ac_word... " >&6; }
5246 if ${ac_cv_path_CMP+:} false; then :
5247   $as_echo_n "(cached) " >&6
5248 else
5249   case $CMP in
5250   [\\/]* | ?:[\\/]*)
5251   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5252   ;;
5253   *)
5254   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5255 for as_dir in $PATH
5256 do
5257   IFS=$as_save_IFS
5258   test -z "$as_dir" && as_dir=.
5259     for ac_exec_ext in '' $ac_executable_extensions; do
5260   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5261     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5262     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5263     break 2
5264   fi
5265 done
5266   done
5267 IFS=$as_save_IFS
5268 
5269   ;;
5270 esac
5271 fi
5272 CMP=$ac_cv_path_CMP
5273 if test -n "$CMP"; then
5274   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5275 $as_echo "$CMP" >&6; }
5276 else
5277   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5278 $as_echo "no" >&6; }
5279 fi
5280 
5281 
5282   test -n "$CMP" && break
5283 done
5284 
5285     else
5286       # If it succeeded, then it was overridden by the user. We will use it
5287       # for the tool.
5288 
5289       # First remove it from the list of overridden variables, so we can test
5290       # for unknown variables in the end.
5291       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5292 
5293       # Check if the provided tool contains a complete path.
5294       tool_specified="$CMP"
5295       tool_basename="${tool_specified##*/}"
5296       if test "x$tool_basename" = "x$tool_specified"; then
5297         # A command without a complete path is provided, search $PATH.
5298         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
5299 $as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
5300         # Extract the first word of "$tool_basename", so it can be a program name with args.
5301 set dummy $tool_basename; ac_word=$2
5302 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5303 $as_echo_n "checking for $ac_word... " >&6; }
5304 if ${ac_cv_path_CMP+:} false; then :
5305   $as_echo_n "(cached) " >&6
5306 else
5307   case $CMP in
5308   [\\/]* | ?:[\\/]*)
5309   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5310   ;;
5311   *)
5312   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5313 for as_dir in $PATH
5314 do
5315   IFS=$as_save_IFS
5316   test -z "$as_dir" && as_dir=.
5317     for ac_exec_ext in '' $ac_executable_extensions; do
5318   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5319     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5320     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5321     break 2
5322   fi
5323 done
5324   done
5325 IFS=$as_save_IFS
5326 
5327   ;;
5328 esac
5329 fi
5330 CMP=$ac_cv_path_CMP
5331 if test -n "$CMP"; then
5332   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5333 $as_echo "$CMP" >&6; }
5334 else
5335   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5336 $as_echo "no" >&6; }
5337 fi
5338 
5339 
5340         if test "x$CMP" = x; then
5341           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5342         fi
5343       else
5344         # Otherwise we believe it is a complete path. Use it as it is.
5345         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
5346 $as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
5347         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
5348 $as_echo_n "checking for CMP... " >&6; }
5349         if test ! -x "$tool_specified"; then
5350           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5351 $as_echo "not found" >&6; }
5352           as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
5353         fi
5354         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5355 $as_echo "$tool_specified" >&6; }
5356       fi
5357     fi
5358   fi
5359 
5360 
5361 
5362   if test "x$CMP" = x; then
5363     as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
5364   fi
5365 
5366 
5367 
5368 
5369 
5370   # Publish this variable in the help.
5371 
5372 
5373   if test "x$COMM" = x; then
5374     # The variable is not set by user, try to locate tool using the code snippet
5375     for ac_prog in comm
5376 do
5377   # Extract the first word of "$ac_prog", so it can be a program name with args.
5378 set dummy $ac_prog; ac_word=$2
5379 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5380 $as_echo_n "checking for $ac_word... " >&6; }
5381 if ${ac_cv_path_COMM+:} false; then :
5382   $as_echo_n "(cached) " >&6
5383 else
5384   case $COMM in
5385   [\\/]* | ?:[\\/]*)
5386   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5387   ;;
5388   *)
5389   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5390 for as_dir in $PATH
5391 do
5392   IFS=$as_save_IFS
5393   test -z "$as_dir" && as_dir=.
5394     for ac_exec_ext in '' $ac_executable_extensions; do
5395   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5396     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5397     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5398     break 2
5399   fi
5400 done
5401   done
5402 IFS=$as_save_IFS
5403 
5404   ;;
5405 esac
5406 fi
5407 COMM=$ac_cv_path_COMM
5408 if test -n "$COMM"; then
5409   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5410 $as_echo "$COMM" >&6; }
5411 else
5412   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5413 $as_echo "no" >&6; }
5414 fi
5415 
5416 
5417   test -n "$COMM" && break
5418 done
5419 
5420   else
5421     # The variable is set, but is it from the command line or the environment?
5422 
5423     # Try to remove the string !COMM! from our list.
5424     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
5425     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5426       # If it failed, the variable was not from the command line. Ignore it,
5427       # but warn the user (except for BASH, which is always set by the calling BASH).
5428       if test "xCOMM" != xBASH; then
5429         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
5430 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
5431       fi
5432       # Try to locate tool using the code snippet
5433       for ac_prog in comm
5434 do
5435   # Extract the first word of "$ac_prog", so it can be a program name with args.
5436 set dummy $ac_prog; ac_word=$2
5437 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5438 $as_echo_n "checking for $ac_word... " >&6; }
5439 if ${ac_cv_path_COMM+:} false; then :
5440   $as_echo_n "(cached) " >&6
5441 else
5442   case $COMM in
5443   [\\/]* | ?:[\\/]*)
5444   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5445   ;;
5446   *)
5447   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5448 for as_dir in $PATH
5449 do
5450   IFS=$as_save_IFS
5451   test -z "$as_dir" && as_dir=.
5452     for ac_exec_ext in '' $ac_executable_extensions; do
5453   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5454     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5455     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5456     break 2
5457   fi
5458 done
5459   done
5460 IFS=$as_save_IFS
5461 
5462   ;;
5463 esac
5464 fi
5465 COMM=$ac_cv_path_COMM
5466 if test -n "$COMM"; then
5467   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5468 $as_echo "$COMM" >&6; }
5469 else
5470   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5471 $as_echo "no" >&6; }
5472 fi
5473 
5474 
5475   test -n "$COMM" && break
5476 done
5477 
5478     else
5479       # If it succeeded, then it was overridden by the user. We will use it
5480       # for the tool.
5481 
5482       # First remove it from the list of overridden variables, so we can test
5483       # for unknown variables in the end.
5484       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5485 
5486       # Check if the provided tool contains a complete path.
5487       tool_specified="$COMM"
5488       tool_basename="${tool_specified##*/}"
5489       if test "x$tool_basename" = "x$tool_specified"; then
5490         # A command without a complete path is provided, search $PATH.
5491         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
5492 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
5493         # Extract the first word of "$tool_basename", so it can be a program name with args.
5494 set dummy $tool_basename; ac_word=$2
5495 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5496 $as_echo_n "checking for $ac_word... " >&6; }
5497 if ${ac_cv_path_COMM+:} false; then :
5498   $as_echo_n "(cached) " >&6
5499 else
5500   case $COMM in
5501   [\\/]* | ?:[\\/]*)
5502   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5503   ;;
5504   *)
5505   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5506 for as_dir in $PATH
5507 do
5508   IFS=$as_save_IFS
5509   test -z "$as_dir" && as_dir=.
5510     for ac_exec_ext in '' $ac_executable_extensions; do
5511   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5512     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5513     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5514     break 2
5515   fi
5516 done
5517   done
5518 IFS=$as_save_IFS
5519 
5520   ;;
5521 esac
5522 fi
5523 COMM=$ac_cv_path_COMM
5524 if test -n "$COMM"; then
5525   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5526 $as_echo "$COMM" >&6; }
5527 else
5528   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5529 $as_echo "no" >&6; }
5530 fi
5531 
5532 
5533         if test "x$COMM" = x; then
5534           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5535         fi
5536       else
5537         # Otherwise we believe it is a complete path. Use it as it is.
5538         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
5539 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
5540         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
5541 $as_echo_n "checking for COMM... " >&6; }
5542         if test ! -x "$tool_specified"; then
5543           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5544 $as_echo "not found" >&6; }
5545           as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
5546         fi
5547         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5548 $as_echo "$tool_specified" >&6; }
5549       fi
5550     fi
5551   fi
5552 
5553 
5554 
5555   if test "x$COMM" = x; then
5556     as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
5557   fi
5558 
5559 
5560 
5561 
5562 
5563   # Publish this variable in the help.
5564 
5565 
5566   if test "x$CP" = x; then
5567     # The variable is not set by user, try to locate tool using the code snippet
5568     for ac_prog in cp
5569 do
5570   # Extract the first word of "$ac_prog", so it can be a program name with args.
5571 set dummy $ac_prog; ac_word=$2
5572 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5573 $as_echo_n "checking for $ac_word... " >&6; }
5574 if ${ac_cv_path_CP+:} false; then :
5575   $as_echo_n "(cached) " >&6
5576 else
5577   case $CP in
5578   [\\/]* | ?:[\\/]*)
5579   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5580   ;;
5581   *)
5582   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5583 for as_dir in $PATH
5584 do
5585   IFS=$as_save_IFS
5586   test -z "$as_dir" && as_dir=.
5587     for ac_exec_ext in '' $ac_executable_extensions; do
5588   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5589     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5590     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5591     break 2
5592   fi
5593 done
5594   done
5595 IFS=$as_save_IFS
5596 
5597   ;;
5598 esac
5599 fi
5600 CP=$ac_cv_path_CP
5601 if test -n "$CP"; then
5602   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5603 $as_echo "$CP" >&6; }
5604 else
5605   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5606 $as_echo "no" >&6; }
5607 fi
5608 
5609 
5610   test -n "$CP" && break
5611 done
5612 
5613   else
5614     # The variable is set, but is it from the command line or the environment?
5615 
5616     # Try to remove the string !CP! from our list.
5617     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
5618     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5619       # If it failed, the variable was not from the command line. Ignore it,
5620       # but warn the user (except for BASH, which is always set by the calling BASH).
5621       if test "xCP" != xBASH; then
5622         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
5623 $as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
5624       fi
5625       # Try to locate tool using the code snippet
5626       for ac_prog in cp
5627 do
5628   # Extract the first word of "$ac_prog", so it can be a program name with args.
5629 set dummy $ac_prog; ac_word=$2
5630 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5631 $as_echo_n "checking for $ac_word... " >&6; }
5632 if ${ac_cv_path_CP+:} false; then :
5633   $as_echo_n "(cached) " >&6
5634 else
5635   case $CP in
5636   [\\/]* | ?:[\\/]*)
5637   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5638   ;;
5639   *)
5640   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5641 for as_dir in $PATH
5642 do
5643   IFS=$as_save_IFS
5644   test -z "$as_dir" && as_dir=.
5645     for ac_exec_ext in '' $ac_executable_extensions; do
5646   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5647     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5648     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5649     break 2
5650   fi
5651 done
5652   done
5653 IFS=$as_save_IFS
5654 
5655   ;;
5656 esac
5657 fi
5658 CP=$ac_cv_path_CP
5659 if test -n "$CP"; then
5660   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5661 $as_echo "$CP" >&6; }
5662 else
5663   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5664 $as_echo "no" >&6; }
5665 fi
5666 
5667 
5668   test -n "$CP" && break
5669 done
5670 
5671     else
5672       # If it succeeded, then it was overridden by the user. We will use it
5673       # for the tool.
5674 
5675       # First remove it from the list of overridden variables, so we can test
5676       # for unknown variables in the end.
5677       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5678 
5679       # Check if the provided tool contains a complete path.
5680       tool_specified="$CP"
5681       tool_basename="${tool_specified##*/}"
5682       if test "x$tool_basename" = "x$tool_specified"; then
5683         # A command without a complete path is provided, search $PATH.
5684         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
5685 $as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
5686         # Extract the first word of "$tool_basename", so it can be a program name with args.
5687 set dummy $tool_basename; ac_word=$2
5688 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5689 $as_echo_n "checking for $ac_word... " >&6; }
5690 if ${ac_cv_path_CP+:} false; then :
5691   $as_echo_n "(cached) " >&6
5692 else
5693   case $CP in
5694   [\\/]* | ?:[\\/]*)
5695   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5696   ;;
5697   *)
5698   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5699 for as_dir in $PATH
5700 do
5701   IFS=$as_save_IFS
5702   test -z "$as_dir" && as_dir=.
5703     for ac_exec_ext in '' $ac_executable_extensions; do
5704   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5705     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5706     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5707     break 2
5708   fi
5709 done
5710   done
5711 IFS=$as_save_IFS
5712 
5713   ;;
5714 esac
5715 fi
5716 CP=$ac_cv_path_CP
5717 if test -n "$CP"; then
5718   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5719 $as_echo "$CP" >&6; }
5720 else
5721   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5722 $as_echo "no" >&6; }
5723 fi
5724 
5725 
5726         if test "x$CP" = x; then
5727           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5728         fi
5729       else
5730         # Otherwise we believe it is a complete path. Use it as it is.
5731         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
5732 $as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
5733         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
5734 $as_echo_n "checking for CP... " >&6; }
5735         if test ! -x "$tool_specified"; then
5736           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5737 $as_echo "not found" >&6; }
5738           as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
5739         fi
5740         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5741 $as_echo "$tool_specified" >&6; }
5742       fi
5743     fi
5744   fi
5745 
5746 
5747 
5748   if test "x$CP" = x; then
5749     as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
5750   fi
5751 
5752 
5753 
5754 
5755 
5756   # Publish this variable in the help.
5757 
5758 
5759   if test "x$CUT" = x; then
5760     # The variable is not set by user, try to locate tool using the code snippet
5761     for ac_prog in cut
5762 do
5763   # Extract the first word of "$ac_prog", so it can be a program name with args.
5764 set dummy $ac_prog; ac_word=$2
5765 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5766 $as_echo_n "checking for $ac_word... " >&6; }
5767 if ${ac_cv_path_CUT+:} false; then :
5768   $as_echo_n "(cached) " >&6
5769 else
5770   case $CUT in
5771   [\\/]* | ?:[\\/]*)
5772   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5773   ;;
5774   *)
5775   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5776 for as_dir in $PATH
5777 do
5778   IFS=$as_save_IFS
5779   test -z "$as_dir" && as_dir=.
5780     for ac_exec_ext in '' $ac_executable_extensions; do
5781   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5782     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5783     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5784     break 2
5785   fi
5786 done
5787   done
5788 IFS=$as_save_IFS
5789 
5790   ;;
5791 esac
5792 fi
5793 CUT=$ac_cv_path_CUT
5794 if test -n "$CUT"; then
5795   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5796 $as_echo "$CUT" >&6; }
5797 else
5798   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5799 $as_echo "no" >&6; }
5800 fi
5801 
5802 
5803   test -n "$CUT" && break
5804 done
5805 
5806   else
5807     # The variable is set, but is it from the command line or the environment?
5808 
5809     # Try to remove the string !CUT! from our list.
5810     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
5811     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5812       # If it failed, the variable was not from the command line. Ignore it,
5813       # but warn the user (except for BASH, which is always set by the calling BASH).
5814       if test "xCUT" != xBASH; then
5815         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
5816 $as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
5817       fi
5818       # Try to locate tool using the code snippet
5819       for ac_prog in cut
5820 do
5821   # Extract the first word of "$ac_prog", so it can be a program name with args.
5822 set dummy $ac_prog; ac_word=$2
5823 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5824 $as_echo_n "checking for $ac_word... " >&6; }
5825 if ${ac_cv_path_CUT+:} false; then :
5826   $as_echo_n "(cached) " >&6
5827 else
5828   case $CUT in
5829   [\\/]* | ?:[\\/]*)
5830   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5831   ;;
5832   *)
5833   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5834 for as_dir in $PATH
5835 do
5836   IFS=$as_save_IFS
5837   test -z "$as_dir" && as_dir=.
5838     for ac_exec_ext in '' $ac_executable_extensions; do
5839   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5840     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5841     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5842     break 2
5843   fi
5844 done
5845   done
5846 IFS=$as_save_IFS
5847 
5848   ;;
5849 esac
5850 fi
5851 CUT=$ac_cv_path_CUT
5852 if test -n "$CUT"; then
5853   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5854 $as_echo "$CUT" >&6; }
5855 else
5856   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5857 $as_echo "no" >&6; }
5858 fi
5859 
5860 
5861   test -n "$CUT" && break
5862 done
5863 
5864     else
5865       # If it succeeded, then it was overridden by the user. We will use it
5866       # for the tool.
5867 
5868       # First remove it from the list of overridden variables, so we can test
5869       # for unknown variables in the end.
5870       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5871 
5872       # Check if the provided tool contains a complete path.
5873       tool_specified="$CUT"
5874       tool_basename="${tool_specified##*/}"
5875       if test "x$tool_basename" = "x$tool_specified"; then
5876         # A command without a complete path is provided, search $PATH.
5877         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
5878 $as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
5879         # Extract the first word of "$tool_basename", so it can be a program name with args.
5880 set dummy $tool_basename; ac_word=$2
5881 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5882 $as_echo_n "checking for $ac_word... " >&6; }
5883 if ${ac_cv_path_CUT+:} false; then :
5884   $as_echo_n "(cached) " >&6
5885 else
5886   case $CUT in
5887   [\\/]* | ?:[\\/]*)
5888   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5889   ;;
5890   *)
5891   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5892 for as_dir in $PATH
5893 do
5894   IFS=$as_save_IFS
5895   test -z "$as_dir" && as_dir=.
5896     for ac_exec_ext in '' $ac_executable_extensions; do
5897   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5898     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5899     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5900     break 2
5901   fi
5902 done
5903   done
5904 IFS=$as_save_IFS
5905 
5906   ;;
5907 esac
5908 fi
5909 CUT=$ac_cv_path_CUT
5910 if test -n "$CUT"; then
5911   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5912 $as_echo "$CUT" >&6; }
5913 else
5914   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5915 $as_echo "no" >&6; }
5916 fi
5917 
5918 
5919         if test "x$CUT" = x; then
5920           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5921         fi
5922       else
5923         # Otherwise we believe it is a complete path. Use it as it is.
5924         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
5925 $as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
5926         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
5927 $as_echo_n "checking for CUT... " >&6; }
5928         if test ! -x "$tool_specified"; then
5929           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5930 $as_echo "not found" >&6; }
5931           as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
5932         fi
5933         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5934 $as_echo "$tool_specified" >&6; }
5935       fi
5936     fi
5937   fi
5938 
5939 
5940 
5941   if test "x$CUT" = x; then
5942     as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
5943   fi
5944 
5945 
5946 
5947 
5948 
5949   # Publish this variable in the help.
5950 
5951 
5952   if test "x$DATE" = x; then
5953     # The variable is not set by user, try to locate tool using the code snippet
5954     for ac_prog in date
5955 do
5956   # Extract the first word of "$ac_prog", so it can be a program name with args.
5957 set dummy $ac_prog; ac_word=$2
5958 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5959 $as_echo_n "checking for $ac_word... " >&6; }
5960 if ${ac_cv_path_DATE+:} false; then :
5961   $as_echo_n "(cached) " >&6
5962 else
5963   case $DATE in
5964   [\\/]* | ?:[\\/]*)
5965   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
5966   ;;
5967   *)
5968   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5969 for as_dir in $PATH
5970 do
5971   IFS=$as_save_IFS
5972   test -z "$as_dir" && as_dir=.
5973     for ac_exec_ext in '' $ac_executable_extensions; do
5974   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5975     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
5976     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5977     break 2
5978   fi
5979 done
5980   done
5981 IFS=$as_save_IFS
5982 
5983   ;;
5984 esac
5985 fi
5986 DATE=$ac_cv_path_DATE
5987 if test -n "$DATE"; then
5988   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
5989 $as_echo "$DATE" >&6; }
5990 else
5991   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5992 $as_echo "no" >&6; }
5993 fi
5994 
5995 
5996   test -n "$DATE" && break
5997 done
5998 
5999   else
6000     # The variable is set, but is it from the command line or the environment?
6001 
6002     # Try to remove the string !DATE! from our list.
6003     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
6004     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6005       # If it failed, the variable was not from the command line. Ignore it,
6006       # but warn the user (except for BASH, which is always set by the calling BASH).
6007       if test "xDATE" != xBASH; then
6008         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
6009 $as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
6010       fi
6011       # Try to locate tool using the code snippet
6012       for ac_prog in date
6013 do
6014   # Extract the first word of "$ac_prog", so it can be a program name with args.
6015 set dummy $ac_prog; ac_word=$2
6016 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6017 $as_echo_n "checking for $ac_word... " >&6; }
6018 if ${ac_cv_path_DATE+:} false; then :
6019   $as_echo_n "(cached) " >&6
6020 else
6021   case $DATE in
6022   [\\/]* | ?:[\\/]*)
6023   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6024   ;;
6025   *)
6026   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6027 for as_dir in $PATH
6028 do
6029   IFS=$as_save_IFS
6030   test -z "$as_dir" && as_dir=.
6031     for ac_exec_ext in '' $ac_executable_extensions; do
6032   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6033     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6034     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6035     break 2
6036   fi
6037 done
6038   done
6039 IFS=$as_save_IFS
6040 
6041   ;;
6042 esac
6043 fi
6044 DATE=$ac_cv_path_DATE
6045 if test -n "$DATE"; then
6046   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6047 $as_echo "$DATE" >&6; }
6048 else
6049   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6050 $as_echo "no" >&6; }
6051 fi
6052 
6053 
6054   test -n "$DATE" && break
6055 done
6056 
6057     else
6058       # If it succeeded, then it was overridden by the user. We will use it
6059       # for the tool.
6060 
6061       # First remove it from the list of overridden variables, so we can test
6062       # for unknown variables in the end.
6063       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6064 
6065       # Check if the provided tool contains a complete path.
6066       tool_specified="$DATE"
6067       tool_basename="${tool_specified##*/}"
6068       if test "x$tool_basename" = "x$tool_specified"; then
6069         # A command without a complete path is provided, search $PATH.
6070         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
6071 $as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
6072         # Extract the first word of "$tool_basename", so it can be a program name with args.
6073 set dummy $tool_basename; ac_word=$2
6074 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6075 $as_echo_n "checking for $ac_word... " >&6; }
6076 if ${ac_cv_path_DATE+:} false; then :
6077   $as_echo_n "(cached) " >&6
6078 else
6079   case $DATE in
6080   [\\/]* | ?:[\\/]*)
6081   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6082   ;;
6083   *)
6084   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6085 for as_dir in $PATH
6086 do
6087   IFS=$as_save_IFS
6088   test -z "$as_dir" && as_dir=.
6089     for ac_exec_ext in '' $ac_executable_extensions; do
6090   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6091     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6092     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6093     break 2
6094   fi
6095 done
6096   done
6097 IFS=$as_save_IFS
6098 
6099   ;;
6100 esac
6101 fi
6102 DATE=$ac_cv_path_DATE
6103 if test -n "$DATE"; then
6104   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6105 $as_echo "$DATE" >&6; }
6106 else
6107   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6108 $as_echo "no" >&6; }
6109 fi
6110 
6111 
6112         if test "x$DATE" = x; then
6113           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6114         fi
6115       else
6116         # Otherwise we believe it is a complete path. Use it as it is.
6117         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
6118 $as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
6119         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6120 $as_echo_n "checking for DATE... " >&6; }
6121         if test ! -x "$tool_specified"; then
6122           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6123 $as_echo "not found" >&6; }
6124           as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
6125         fi
6126         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6127 $as_echo "$tool_specified" >&6; }
6128       fi
6129     fi
6130   fi
6131 
6132 
6133 
6134   if test "x$DATE" = x; then
6135     as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
6136   fi
6137 
6138 
6139 
6140 
6141 
6142   # Publish this variable in the help.
6143 
6144 
6145   if test "x$DIFF" = x; then
6146     # The variable is not set by user, try to locate tool using the code snippet
6147     for ac_prog in gdiff diff
6148 do
6149   # Extract the first word of "$ac_prog", so it can be a program name with args.
6150 set dummy $ac_prog; ac_word=$2
6151 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6152 $as_echo_n "checking for $ac_word... " >&6; }
6153 if ${ac_cv_path_DIFF+:} false; then :
6154   $as_echo_n "(cached) " >&6
6155 else
6156   case $DIFF in
6157   [\\/]* | ?:[\\/]*)
6158   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6159   ;;
6160   *)
6161   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6162 for as_dir in $PATH
6163 do
6164   IFS=$as_save_IFS
6165   test -z "$as_dir" && as_dir=.
6166     for ac_exec_ext in '' $ac_executable_extensions; do
6167   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6168     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6169     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6170     break 2
6171   fi
6172 done
6173   done
6174 IFS=$as_save_IFS
6175 
6176   ;;
6177 esac
6178 fi
6179 DIFF=$ac_cv_path_DIFF
6180 if test -n "$DIFF"; then
6181   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6182 $as_echo "$DIFF" >&6; }
6183 else
6184   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6185 $as_echo "no" >&6; }
6186 fi
6187 
6188 
6189   test -n "$DIFF" && break
6190 done
6191 
6192   else
6193     # The variable is set, but is it from the command line or the environment?
6194 
6195     # Try to remove the string !DIFF! from our list.
6196     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
6197     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6198       # If it failed, the variable was not from the command line. Ignore it,
6199       # but warn the user (except for BASH, which is always set by the calling BASH).
6200       if test "xDIFF" != xBASH; then
6201         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
6202 $as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
6203       fi
6204       # Try to locate tool using the code snippet
6205       for ac_prog in gdiff diff
6206 do
6207   # Extract the first word of "$ac_prog", so it can be a program name with args.
6208 set dummy $ac_prog; ac_word=$2
6209 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6210 $as_echo_n "checking for $ac_word... " >&6; }
6211 if ${ac_cv_path_DIFF+:} false; then :
6212   $as_echo_n "(cached) " >&6
6213 else
6214   case $DIFF in
6215   [\\/]* | ?:[\\/]*)
6216   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6217   ;;
6218   *)
6219   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6220 for as_dir in $PATH
6221 do
6222   IFS=$as_save_IFS
6223   test -z "$as_dir" && as_dir=.
6224     for ac_exec_ext in '' $ac_executable_extensions; do
6225   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6226     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6227     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6228     break 2
6229   fi
6230 done
6231   done
6232 IFS=$as_save_IFS
6233 
6234   ;;
6235 esac
6236 fi
6237 DIFF=$ac_cv_path_DIFF
6238 if test -n "$DIFF"; then
6239   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6240 $as_echo "$DIFF" >&6; }
6241 else
6242   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6243 $as_echo "no" >&6; }
6244 fi
6245 
6246 
6247   test -n "$DIFF" && break
6248 done
6249 
6250     else
6251       # If it succeeded, then it was overridden by the user. We will use it
6252       # for the tool.
6253 
6254       # First remove it from the list of overridden variables, so we can test
6255       # for unknown variables in the end.
6256       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6257 
6258       # Check if the provided tool contains a complete path.
6259       tool_specified="$DIFF"
6260       tool_basename="${tool_specified##*/}"
6261       if test "x$tool_basename" = "x$tool_specified"; then
6262         # A command without a complete path is provided, search $PATH.
6263         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
6264 $as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
6265         # Extract the first word of "$tool_basename", so it can be a program name with args.
6266 set dummy $tool_basename; ac_word=$2
6267 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6268 $as_echo_n "checking for $ac_word... " >&6; }
6269 if ${ac_cv_path_DIFF+:} false; then :
6270   $as_echo_n "(cached) " >&6
6271 else
6272   case $DIFF in
6273   [\\/]* | ?:[\\/]*)
6274   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6275   ;;
6276   *)
6277   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6278 for as_dir in $PATH
6279 do
6280   IFS=$as_save_IFS
6281   test -z "$as_dir" && as_dir=.
6282     for ac_exec_ext in '' $ac_executable_extensions; do
6283   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6284     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6285     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6286     break 2
6287   fi
6288 done
6289   done
6290 IFS=$as_save_IFS
6291 
6292   ;;
6293 esac
6294 fi
6295 DIFF=$ac_cv_path_DIFF
6296 if test -n "$DIFF"; then
6297   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6298 $as_echo "$DIFF" >&6; }
6299 else
6300   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6301 $as_echo "no" >&6; }
6302 fi
6303 
6304 
6305         if test "x$DIFF" = x; then
6306           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6307         fi
6308       else
6309         # Otherwise we believe it is a complete path. Use it as it is.
6310         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
6311 $as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
6312         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
6313 $as_echo_n "checking for DIFF... " >&6; }
6314         if test ! -x "$tool_specified"; then
6315           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6316 $as_echo "not found" >&6; }
6317           as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
6318         fi
6319         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6320 $as_echo "$tool_specified" >&6; }
6321       fi
6322     fi
6323   fi
6324 
6325 
6326 
6327   if test "x$DIFF" = x; then
6328     as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
6329   fi
6330 
6331 
6332 
6333 
6334 
6335   # Publish this variable in the help.
6336 
6337 
6338   if test "x$DIRNAME" = x; then
6339     # The variable is not set by user, try to locate tool using the code snippet
6340     for ac_prog in dirname
6341 do
6342   # Extract the first word of "$ac_prog", so it can be a program name with args.
6343 set dummy $ac_prog; ac_word=$2
6344 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6345 $as_echo_n "checking for $ac_word... " >&6; }
6346 if ${ac_cv_path_DIRNAME+:} false; then :
6347   $as_echo_n "(cached) " >&6
6348 else
6349   case $DIRNAME in
6350   [\\/]* | ?:[\\/]*)
6351   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6352   ;;
6353   *)
6354   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6355 for as_dir in $PATH
6356 do
6357   IFS=$as_save_IFS
6358   test -z "$as_dir" && as_dir=.
6359     for ac_exec_ext in '' $ac_executable_extensions; do
6360   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6361     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6362     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6363     break 2
6364   fi
6365 done
6366   done
6367 IFS=$as_save_IFS
6368 
6369   ;;
6370 esac
6371 fi
6372 DIRNAME=$ac_cv_path_DIRNAME
6373 if test -n "$DIRNAME"; then
6374   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6375 $as_echo "$DIRNAME" >&6; }
6376 else
6377   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6378 $as_echo "no" >&6; }
6379 fi
6380 
6381 
6382   test -n "$DIRNAME" && break
6383 done
6384 
6385   else
6386     # The variable is set, but is it from the command line or the environment?
6387 
6388     # Try to remove the string !DIRNAME! from our list.
6389     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
6390     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6391       # If it failed, the variable was not from the command line. Ignore it,
6392       # but warn the user (except for BASH, which is always set by the calling BASH).
6393       if test "xDIRNAME" != xBASH; then
6394         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
6395 $as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
6396       fi
6397       # Try to locate tool using the code snippet
6398       for ac_prog in dirname
6399 do
6400   # Extract the first word of "$ac_prog", so it can be a program name with args.
6401 set dummy $ac_prog; ac_word=$2
6402 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6403 $as_echo_n "checking for $ac_word... " >&6; }
6404 if ${ac_cv_path_DIRNAME+:} false; then :
6405   $as_echo_n "(cached) " >&6
6406 else
6407   case $DIRNAME in
6408   [\\/]* | ?:[\\/]*)
6409   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6410   ;;
6411   *)
6412   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6413 for as_dir in $PATH
6414 do
6415   IFS=$as_save_IFS
6416   test -z "$as_dir" && as_dir=.
6417     for ac_exec_ext in '' $ac_executable_extensions; do
6418   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6419     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6420     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6421     break 2
6422   fi
6423 done
6424   done
6425 IFS=$as_save_IFS
6426 
6427   ;;
6428 esac
6429 fi
6430 DIRNAME=$ac_cv_path_DIRNAME
6431 if test -n "$DIRNAME"; then
6432   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6433 $as_echo "$DIRNAME" >&6; }
6434 else
6435   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6436 $as_echo "no" >&6; }
6437 fi
6438 
6439 
6440   test -n "$DIRNAME" && break
6441 done
6442 
6443     else
6444       # If it succeeded, then it was overridden by the user. We will use it
6445       # for the tool.
6446 
6447       # First remove it from the list of overridden variables, so we can test
6448       # for unknown variables in the end.
6449       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6450 
6451       # Check if the provided tool contains a complete path.
6452       tool_specified="$DIRNAME"
6453       tool_basename="${tool_specified##*/}"
6454       if test "x$tool_basename" = "x$tool_specified"; then
6455         # A command without a complete path is provided, search $PATH.
6456         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
6457 $as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
6458         # Extract the first word of "$tool_basename", so it can be a program name with args.
6459 set dummy $tool_basename; ac_word=$2
6460 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6461 $as_echo_n "checking for $ac_word... " >&6; }
6462 if ${ac_cv_path_DIRNAME+:} false; then :
6463   $as_echo_n "(cached) " >&6
6464 else
6465   case $DIRNAME in
6466   [\\/]* | ?:[\\/]*)
6467   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6468   ;;
6469   *)
6470   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6471 for as_dir in $PATH
6472 do
6473   IFS=$as_save_IFS
6474   test -z "$as_dir" && as_dir=.
6475     for ac_exec_ext in '' $ac_executable_extensions; do
6476   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6477     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6478     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6479     break 2
6480   fi
6481 done
6482   done
6483 IFS=$as_save_IFS
6484 
6485   ;;
6486 esac
6487 fi
6488 DIRNAME=$ac_cv_path_DIRNAME
6489 if test -n "$DIRNAME"; then
6490   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6491 $as_echo "$DIRNAME" >&6; }
6492 else
6493   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6494 $as_echo "no" >&6; }
6495 fi
6496 
6497 
6498         if test "x$DIRNAME" = x; then
6499           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6500         fi
6501       else
6502         # Otherwise we believe it is a complete path. Use it as it is.
6503         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
6504 $as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
6505         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
6506 $as_echo_n "checking for DIRNAME... " >&6; }
6507         if test ! -x "$tool_specified"; then
6508           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6509 $as_echo "not found" >&6; }
6510           as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
6511         fi
6512         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6513 $as_echo "$tool_specified" >&6; }
6514       fi
6515     fi
6516   fi
6517 
6518 
6519 
6520   if test "x$DIRNAME" = x; then
6521     as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
6522   fi
6523 
6524 
6525 
6526 
6527 
6528   # Publish this variable in the help.
6529 
6530 
6531   if test "x$ECHO" = x; then
6532     # The variable is not set by user, try to locate tool using the code snippet
6533     for ac_prog in echo
6534 do
6535   # Extract the first word of "$ac_prog", so it can be a program name with args.
6536 set dummy $ac_prog; ac_word=$2
6537 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6538 $as_echo_n "checking for $ac_word... " >&6; }
6539 if ${ac_cv_path_ECHO+:} false; then :
6540   $as_echo_n "(cached) " >&6
6541 else
6542   case $ECHO in
6543   [\\/]* | ?:[\\/]*)
6544   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6545   ;;
6546   *)
6547   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6548 for as_dir in $PATH
6549 do
6550   IFS=$as_save_IFS
6551   test -z "$as_dir" && as_dir=.
6552     for ac_exec_ext in '' $ac_executable_extensions; do
6553   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6554     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6555     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6556     break 2
6557   fi
6558 done
6559   done
6560 IFS=$as_save_IFS
6561 
6562   ;;
6563 esac
6564 fi
6565 ECHO=$ac_cv_path_ECHO
6566 if test -n "$ECHO"; then
6567   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6568 $as_echo "$ECHO" >&6; }
6569 else
6570   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6571 $as_echo "no" >&6; }
6572 fi
6573 
6574 
6575   test -n "$ECHO" && break
6576 done
6577 
6578   else
6579     # The variable is set, but is it from the command line or the environment?
6580 
6581     # Try to remove the string !ECHO! from our list.
6582     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
6583     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6584       # If it failed, the variable was not from the command line. Ignore it,
6585       # but warn the user (except for BASH, which is always set by the calling BASH).
6586       if test "xECHO" != xBASH; then
6587         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
6588 $as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
6589       fi
6590       # Try to locate tool using the code snippet
6591       for ac_prog in echo
6592 do
6593   # Extract the first word of "$ac_prog", so it can be a program name with args.
6594 set dummy $ac_prog; ac_word=$2
6595 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6596 $as_echo_n "checking for $ac_word... " >&6; }
6597 if ${ac_cv_path_ECHO+:} false; then :
6598   $as_echo_n "(cached) " >&6
6599 else
6600   case $ECHO in
6601   [\\/]* | ?:[\\/]*)
6602   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6603   ;;
6604   *)
6605   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6606 for as_dir in $PATH
6607 do
6608   IFS=$as_save_IFS
6609   test -z "$as_dir" && as_dir=.
6610     for ac_exec_ext in '' $ac_executable_extensions; do
6611   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6612     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6613     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6614     break 2
6615   fi
6616 done
6617   done
6618 IFS=$as_save_IFS
6619 
6620   ;;
6621 esac
6622 fi
6623 ECHO=$ac_cv_path_ECHO
6624 if test -n "$ECHO"; then
6625   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6626 $as_echo "$ECHO" >&6; }
6627 else
6628   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6629 $as_echo "no" >&6; }
6630 fi
6631 
6632 
6633   test -n "$ECHO" && break
6634 done
6635 
6636     else
6637       # If it succeeded, then it was overridden by the user. We will use it
6638       # for the tool.
6639 
6640       # First remove it from the list of overridden variables, so we can test
6641       # for unknown variables in the end.
6642       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6643 
6644       # Check if the provided tool contains a complete path.
6645       tool_specified="$ECHO"
6646       tool_basename="${tool_specified##*/}"
6647       if test "x$tool_basename" = "x$tool_specified"; then
6648         # A command without a complete path is provided, search $PATH.
6649         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
6650 $as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
6651         # Extract the first word of "$tool_basename", so it can be a program name with args.
6652 set dummy $tool_basename; ac_word=$2
6653 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6654 $as_echo_n "checking for $ac_word... " >&6; }
6655 if ${ac_cv_path_ECHO+:} false; then :
6656   $as_echo_n "(cached) " >&6
6657 else
6658   case $ECHO in
6659   [\\/]* | ?:[\\/]*)
6660   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6661   ;;
6662   *)
6663   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6664 for as_dir in $PATH
6665 do
6666   IFS=$as_save_IFS
6667   test -z "$as_dir" && as_dir=.
6668     for ac_exec_ext in '' $ac_executable_extensions; do
6669   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6670     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6671     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6672     break 2
6673   fi
6674 done
6675   done
6676 IFS=$as_save_IFS
6677 
6678   ;;
6679 esac
6680 fi
6681 ECHO=$ac_cv_path_ECHO
6682 if test -n "$ECHO"; then
6683   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6684 $as_echo "$ECHO" >&6; }
6685 else
6686   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6687 $as_echo "no" >&6; }
6688 fi
6689 
6690 
6691         if test "x$ECHO" = x; then
6692           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6693         fi
6694       else
6695         # Otherwise we believe it is a complete path. Use it as it is.
6696         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
6697 $as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
6698         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
6699 $as_echo_n "checking for ECHO... " >&6; }
6700         if test ! -x "$tool_specified"; then
6701           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6702 $as_echo "not found" >&6; }
6703           as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
6704         fi
6705         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6706 $as_echo "$tool_specified" >&6; }
6707       fi
6708     fi
6709   fi
6710 
6711 
6712 
6713   if test "x$ECHO" = x; then
6714     as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
6715   fi
6716 
6717 
6718 
6719 
6720 
6721   # Publish this variable in the help.
6722 
6723 
6724   if test "x$EXPR" = x; then
6725     # The variable is not set by user, try to locate tool using the code snippet
6726     for ac_prog in expr
6727 do
6728   # Extract the first word of "$ac_prog", so it can be a program name with args.
6729 set dummy $ac_prog; ac_word=$2
6730 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6731 $as_echo_n "checking for $ac_word... " >&6; }
6732 if ${ac_cv_path_EXPR+:} false; then :
6733   $as_echo_n "(cached) " >&6
6734 else
6735   case $EXPR in
6736   [\\/]* | ?:[\\/]*)
6737   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6738   ;;
6739   *)
6740   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6741 for as_dir in $PATH
6742 do
6743   IFS=$as_save_IFS
6744   test -z "$as_dir" && as_dir=.
6745     for ac_exec_ext in '' $ac_executable_extensions; do
6746   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6747     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6748     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6749     break 2
6750   fi
6751 done
6752   done
6753 IFS=$as_save_IFS
6754 
6755   ;;
6756 esac
6757 fi
6758 EXPR=$ac_cv_path_EXPR
6759 if test -n "$EXPR"; then
6760   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6761 $as_echo "$EXPR" >&6; }
6762 else
6763   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6764 $as_echo "no" >&6; }
6765 fi
6766 
6767 
6768   test -n "$EXPR" && break
6769 done
6770 
6771   else
6772     # The variable is set, but is it from the command line or the environment?
6773 
6774     # Try to remove the string !EXPR! from our list.
6775     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
6776     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6777       # If it failed, the variable was not from the command line. Ignore it,
6778       # but warn the user (except for BASH, which is always set by the calling BASH).
6779       if test "xEXPR" != xBASH; then
6780         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
6781 $as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
6782       fi
6783       # Try to locate tool using the code snippet
6784       for ac_prog in expr
6785 do
6786   # Extract the first word of "$ac_prog", so it can be a program name with args.
6787 set dummy $ac_prog; ac_word=$2
6788 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6789 $as_echo_n "checking for $ac_word... " >&6; }
6790 if ${ac_cv_path_EXPR+:} false; then :
6791   $as_echo_n "(cached) " >&6
6792 else
6793   case $EXPR in
6794   [\\/]* | ?:[\\/]*)
6795   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6796   ;;
6797   *)
6798   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6799 for as_dir in $PATH
6800 do
6801   IFS=$as_save_IFS
6802   test -z "$as_dir" && as_dir=.
6803     for ac_exec_ext in '' $ac_executable_extensions; do
6804   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6805     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6806     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6807     break 2
6808   fi
6809 done
6810   done
6811 IFS=$as_save_IFS
6812 
6813   ;;
6814 esac
6815 fi
6816 EXPR=$ac_cv_path_EXPR
6817 if test -n "$EXPR"; then
6818   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6819 $as_echo "$EXPR" >&6; }
6820 else
6821   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6822 $as_echo "no" >&6; }
6823 fi
6824 
6825 
6826   test -n "$EXPR" && break
6827 done
6828 
6829     else
6830       # If it succeeded, then it was overridden by the user. We will use it
6831       # for the tool.
6832 
6833       # First remove it from the list of overridden variables, so we can test
6834       # for unknown variables in the end.
6835       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6836 
6837       # Check if the provided tool contains a complete path.
6838       tool_specified="$EXPR"
6839       tool_basename="${tool_specified##*/}"
6840       if test "x$tool_basename" = "x$tool_specified"; then
6841         # A command without a complete path is provided, search $PATH.
6842         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
6843 $as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
6844         # Extract the first word of "$tool_basename", so it can be a program name with args.
6845 set dummy $tool_basename; ac_word=$2
6846 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6847 $as_echo_n "checking for $ac_word... " >&6; }
6848 if ${ac_cv_path_EXPR+:} false; then :
6849   $as_echo_n "(cached) " >&6
6850 else
6851   case $EXPR in
6852   [\\/]* | ?:[\\/]*)
6853   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6854   ;;
6855   *)
6856   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6857 for as_dir in $PATH
6858 do
6859   IFS=$as_save_IFS
6860   test -z "$as_dir" && as_dir=.
6861     for ac_exec_ext in '' $ac_executable_extensions; do
6862   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6863     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6864     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6865     break 2
6866   fi
6867 done
6868   done
6869 IFS=$as_save_IFS
6870 
6871   ;;
6872 esac
6873 fi
6874 EXPR=$ac_cv_path_EXPR
6875 if test -n "$EXPR"; then
6876   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6877 $as_echo "$EXPR" >&6; }
6878 else
6879   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6880 $as_echo "no" >&6; }
6881 fi
6882 
6883 
6884         if test "x$EXPR" = x; then
6885           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6886         fi
6887       else
6888         # Otherwise we believe it is a complete path. Use it as it is.
6889         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
6890 $as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
6891         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
6892 $as_echo_n "checking for EXPR... " >&6; }
6893         if test ! -x "$tool_specified"; then
6894           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6895 $as_echo "not found" >&6; }
6896           as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
6897         fi
6898         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6899 $as_echo "$tool_specified" >&6; }
6900       fi
6901     fi
6902   fi
6903 
6904 
6905 
6906   if test "x$EXPR" = x; then
6907     as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
6908   fi
6909 
6910 
6911 
6912 
6913 
6914   # Publish this variable in the help.
6915 
6916 
6917   if test "x$FILE" = x; then
6918     # The variable is not set by user, try to locate tool using the code snippet
6919     for ac_prog in file
6920 do
6921   # Extract the first word of "$ac_prog", so it can be a program name with args.
6922 set dummy $ac_prog; ac_word=$2
6923 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6924 $as_echo_n "checking for $ac_word... " >&6; }
6925 if ${ac_cv_path_FILE+:} false; then :
6926   $as_echo_n "(cached) " >&6
6927 else
6928   case $FILE in
6929   [\\/]* | ?:[\\/]*)
6930   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
6931   ;;
6932   *)
6933   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6934 for as_dir in $PATH
6935 do
6936   IFS=$as_save_IFS
6937   test -z "$as_dir" && as_dir=.
6938     for ac_exec_ext in '' $ac_executable_extensions; do
6939   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6940     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
6941     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6942     break 2
6943   fi
6944 done
6945   done
6946 IFS=$as_save_IFS
6947 
6948   ;;
6949 esac
6950 fi
6951 FILE=$ac_cv_path_FILE
6952 if test -n "$FILE"; then
6953   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
6954 $as_echo "$FILE" >&6; }
6955 else
6956   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6957 $as_echo "no" >&6; }
6958 fi
6959 
6960 
6961   test -n "$FILE" && break
6962 done
6963 
6964   else
6965     # The variable is set, but is it from the command line or the environment?
6966 
6967     # Try to remove the string !FILE! from our list.
6968     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
6969     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6970       # If it failed, the variable was not from the command line. Ignore it,
6971       # but warn the user (except for BASH, which is always set by the calling BASH).
6972       if test "xFILE" != xBASH; then
6973         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
6974 $as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
6975       fi
6976       # Try to locate tool using the code snippet
6977       for ac_prog in file
6978 do
6979   # Extract the first word of "$ac_prog", so it can be a program name with args.
6980 set dummy $ac_prog; ac_word=$2
6981 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6982 $as_echo_n "checking for $ac_word... " >&6; }
6983 if ${ac_cv_path_FILE+:} false; then :
6984   $as_echo_n "(cached) " >&6
6985 else
6986   case $FILE in
6987   [\\/]* | ?:[\\/]*)
6988   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
6989   ;;
6990   *)
6991   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6992 for as_dir in $PATH
6993 do
6994   IFS=$as_save_IFS
6995   test -z "$as_dir" && as_dir=.
6996     for ac_exec_ext in '' $ac_executable_extensions; do
6997   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6998     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
6999     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7000     break 2
7001   fi
7002 done
7003   done
7004 IFS=$as_save_IFS
7005 
7006   ;;
7007 esac
7008 fi
7009 FILE=$ac_cv_path_FILE
7010 if test -n "$FILE"; then
7011   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7012 $as_echo "$FILE" >&6; }
7013 else
7014   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7015 $as_echo "no" >&6; }
7016 fi
7017 
7018 
7019   test -n "$FILE" && break
7020 done
7021 
7022     else
7023       # If it succeeded, then it was overridden by the user. We will use it
7024       # for the tool.
7025 
7026       # First remove it from the list of overridden variables, so we can test
7027       # for unknown variables in the end.
7028       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7029 
7030       # Check if the provided tool contains a complete path.
7031       tool_specified="$FILE"
7032       tool_basename="${tool_specified##*/}"
7033       if test "x$tool_basename" = "x$tool_specified"; then
7034         # A command without a complete path is provided, search $PATH.
7035         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
7036 $as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
7037         # Extract the first word of "$tool_basename", so it can be a program name with args.
7038 set dummy $tool_basename; ac_word=$2
7039 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7040 $as_echo_n "checking for $ac_word... " >&6; }
7041 if ${ac_cv_path_FILE+:} false; then :
7042   $as_echo_n "(cached) " >&6
7043 else
7044   case $FILE in
7045   [\\/]* | ?:[\\/]*)
7046   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7047   ;;
7048   *)
7049   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7050 for as_dir in $PATH
7051 do
7052   IFS=$as_save_IFS
7053   test -z "$as_dir" && as_dir=.
7054     for ac_exec_ext in '' $ac_executable_extensions; do
7055   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7056     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7057     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7058     break 2
7059   fi
7060 done
7061   done
7062 IFS=$as_save_IFS
7063 
7064   ;;
7065 esac
7066 fi
7067 FILE=$ac_cv_path_FILE
7068 if test -n "$FILE"; then
7069   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7070 $as_echo "$FILE" >&6; }
7071 else
7072   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7073 $as_echo "no" >&6; }
7074 fi
7075 
7076 
7077         if test "x$FILE" = x; then
7078           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7079         fi
7080       else
7081         # Otherwise we believe it is a complete path. Use it as it is.
7082         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
7083 $as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
7084         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7085 $as_echo_n "checking for FILE... " >&6; }
7086         if test ! -x "$tool_specified"; then
7087           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7088 $as_echo "not found" >&6; }
7089           as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
7090         fi
7091         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7092 $as_echo "$tool_specified" >&6; }
7093       fi
7094     fi
7095   fi
7096 
7097 
7098 
7099   if test "x$FILE" = x; then
7100     as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
7101   fi
7102 
7103 
7104 
7105 
7106 
7107   # Publish this variable in the help.
7108 
7109 
7110   if test "x$FIND" = x; then
7111     # The variable is not set by user, try to locate tool using the code snippet
7112     for ac_prog in find
7113 do
7114   # Extract the first word of "$ac_prog", so it can be a program name with args.
7115 set dummy $ac_prog; ac_word=$2
7116 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7117 $as_echo_n "checking for $ac_word... " >&6; }
7118 if ${ac_cv_path_FIND+:} false; then :
7119   $as_echo_n "(cached) " >&6
7120 else
7121   case $FIND in
7122   [\\/]* | ?:[\\/]*)
7123   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7124   ;;
7125   *)
7126   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7127 for as_dir in $PATH
7128 do
7129   IFS=$as_save_IFS
7130   test -z "$as_dir" && as_dir=.
7131     for ac_exec_ext in '' $ac_executable_extensions; do
7132   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7133     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7134     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7135     break 2
7136   fi
7137 done
7138   done
7139 IFS=$as_save_IFS
7140 
7141   ;;
7142 esac
7143 fi
7144 FIND=$ac_cv_path_FIND
7145 if test -n "$FIND"; then
7146   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7147 $as_echo "$FIND" >&6; }
7148 else
7149   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7150 $as_echo "no" >&6; }
7151 fi
7152 
7153 
7154   test -n "$FIND" && break
7155 done
7156 
7157   else
7158     # The variable is set, but is it from the command line or the environment?
7159 
7160     # Try to remove the string !FIND! from our list.
7161     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
7162     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7163       # If it failed, the variable was not from the command line. Ignore it,
7164       # but warn the user (except for BASH, which is always set by the calling BASH).
7165       if test "xFIND" != xBASH; then
7166         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
7167 $as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
7168       fi
7169       # Try to locate tool using the code snippet
7170       for ac_prog in find
7171 do
7172   # Extract the first word of "$ac_prog", so it can be a program name with args.
7173 set dummy $ac_prog; ac_word=$2
7174 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7175 $as_echo_n "checking for $ac_word... " >&6; }
7176 if ${ac_cv_path_FIND+:} false; then :
7177   $as_echo_n "(cached) " >&6
7178 else
7179   case $FIND in
7180   [\\/]* | ?:[\\/]*)
7181   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7182   ;;
7183   *)
7184   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7185 for as_dir in $PATH
7186 do
7187   IFS=$as_save_IFS
7188   test -z "$as_dir" && as_dir=.
7189     for ac_exec_ext in '' $ac_executable_extensions; do
7190   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7191     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7192     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7193     break 2
7194   fi
7195 done
7196   done
7197 IFS=$as_save_IFS
7198 
7199   ;;
7200 esac
7201 fi
7202 FIND=$ac_cv_path_FIND
7203 if test -n "$FIND"; then
7204   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7205 $as_echo "$FIND" >&6; }
7206 else
7207   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7208 $as_echo "no" >&6; }
7209 fi
7210 
7211 
7212   test -n "$FIND" && break
7213 done
7214 
7215     else
7216       # If it succeeded, then it was overridden by the user. We will use it
7217       # for the tool.
7218 
7219       # First remove it from the list of overridden variables, so we can test
7220       # for unknown variables in the end.
7221       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7222 
7223       # Check if the provided tool contains a complete path.
7224       tool_specified="$FIND"
7225       tool_basename="${tool_specified##*/}"
7226       if test "x$tool_basename" = "x$tool_specified"; then
7227         # A command without a complete path is provided, search $PATH.
7228         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
7229 $as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
7230         # Extract the first word of "$tool_basename", so it can be a program name with args.
7231 set dummy $tool_basename; ac_word=$2
7232 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7233 $as_echo_n "checking for $ac_word... " >&6; }
7234 if ${ac_cv_path_FIND+:} false; then :
7235   $as_echo_n "(cached) " >&6
7236 else
7237   case $FIND in
7238   [\\/]* | ?:[\\/]*)
7239   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7240   ;;
7241   *)
7242   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7243 for as_dir in $PATH
7244 do
7245   IFS=$as_save_IFS
7246   test -z "$as_dir" && as_dir=.
7247     for ac_exec_ext in '' $ac_executable_extensions; do
7248   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7249     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7250     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7251     break 2
7252   fi
7253 done
7254   done
7255 IFS=$as_save_IFS
7256 
7257   ;;
7258 esac
7259 fi
7260 FIND=$ac_cv_path_FIND
7261 if test -n "$FIND"; then
7262   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7263 $as_echo "$FIND" >&6; }
7264 else
7265   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7266 $as_echo "no" >&6; }
7267 fi
7268 
7269 
7270         if test "x$FIND" = x; then
7271           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7272         fi
7273       else
7274         # Otherwise we believe it is a complete path. Use it as it is.
7275         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
7276 $as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
7277         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
7278 $as_echo_n "checking for FIND... " >&6; }
7279         if test ! -x "$tool_specified"; then
7280           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7281 $as_echo "not found" >&6; }
7282           as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
7283         fi
7284         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7285 $as_echo "$tool_specified" >&6; }
7286       fi
7287     fi
7288   fi
7289 
7290 
7291 
7292   if test "x$FIND" = x; then
7293     as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
7294   fi
7295 
7296 
7297 
7298 
7299 
7300   # Publish this variable in the help.
7301 
7302 
7303   if test "x$HEAD" = x; then
7304     # The variable is not set by user, try to locate tool using the code snippet
7305     for ac_prog in head
7306 do
7307   # Extract the first word of "$ac_prog", so it can be a program name with args.
7308 set dummy $ac_prog; ac_word=$2
7309 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7310 $as_echo_n "checking for $ac_word... " >&6; }
7311 if ${ac_cv_path_HEAD+:} false; then :
7312   $as_echo_n "(cached) " >&6
7313 else
7314   case $HEAD in
7315   [\\/]* | ?:[\\/]*)
7316   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7317   ;;
7318   *)
7319   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7320 for as_dir in $PATH
7321 do
7322   IFS=$as_save_IFS
7323   test -z "$as_dir" && as_dir=.
7324     for ac_exec_ext in '' $ac_executable_extensions; do
7325   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7326     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7327     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7328     break 2
7329   fi
7330 done
7331   done
7332 IFS=$as_save_IFS
7333 
7334   ;;
7335 esac
7336 fi
7337 HEAD=$ac_cv_path_HEAD
7338 if test -n "$HEAD"; then
7339   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7340 $as_echo "$HEAD" >&6; }
7341 else
7342   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7343 $as_echo "no" >&6; }
7344 fi
7345 
7346 
7347   test -n "$HEAD" && break
7348 done
7349 
7350   else
7351     # The variable is set, but is it from the command line or the environment?
7352 
7353     # Try to remove the string !HEAD! from our list.
7354     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
7355     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7356       # If it failed, the variable was not from the command line. Ignore it,
7357       # but warn the user (except for BASH, which is always set by the calling BASH).
7358       if test "xHEAD" != xBASH; then
7359         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
7360 $as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
7361       fi
7362       # Try to locate tool using the code snippet
7363       for ac_prog in head
7364 do
7365   # Extract the first word of "$ac_prog", so it can be a program name with args.
7366 set dummy $ac_prog; ac_word=$2
7367 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7368 $as_echo_n "checking for $ac_word... " >&6; }
7369 if ${ac_cv_path_HEAD+:} false; then :
7370   $as_echo_n "(cached) " >&6
7371 else
7372   case $HEAD in
7373   [\\/]* | ?:[\\/]*)
7374   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7375   ;;
7376   *)
7377   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7378 for as_dir in $PATH
7379 do
7380   IFS=$as_save_IFS
7381   test -z "$as_dir" && as_dir=.
7382     for ac_exec_ext in '' $ac_executable_extensions; do
7383   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7384     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7385     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7386     break 2
7387   fi
7388 done
7389   done
7390 IFS=$as_save_IFS
7391 
7392   ;;
7393 esac
7394 fi
7395 HEAD=$ac_cv_path_HEAD
7396 if test -n "$HEAD"; then
7397   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7398 $as_echo "$HEAD" >&6; }
7399 else
7400   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7401 $as_echo "no" >&6; }
7402 fi
7403 
7404 
7405   test -n "$HEAD" && break
7406 done
7407 
7408     else
7409       # If it succeeded, then it was overridden by the user. We will use it
7410       # for the tool.
7411 
7412       # First remove it from the list of overridden variables, so we can test
7413       # for unknown variables in the end.
7414       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7415 
7416       # Check if the provided tool contains a complete path.
7417       tool_specified="$HEAD"
7418       tool_basename="${tool_specified##*/}"
7419       if test "x$tool_basename" = "x$tool_specified"; then
7420         # A command without a complete path is provided, search $PATH.
7421         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
7422 $as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
7423         # Extract the first word of "$tool_basename", so it can be a program name with args.
7424 set dummy $tool_basename; ac_word=$2
7425 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7426 $as_echo_n "checking for $ac_word... " >&6; }
7427 if ${ac_cv_path_HEAD+:} false; then :
7428   $as_echo_n "(cached) " >&6
7429 else
7430   case $HEAD in
7431   [\\/]* | ?:[\\/]*)
7432   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7433   ;;
7434   *)
7435   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7436 for as_dir in $PATH
7437 do
7438   IFS=$as_save_IFS
7439   test -z "$as_dir" && as_dir=.
7440     for ac_exec_ext in '' $ac_executable_extensions; do
7441   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7442     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7443     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7444     break 2
7445   fi
7446 done
7447   done
7448 IFS=$as_save_IFS
7449 
7450   ;;
7451 esac
7452 fi
7453 HEAD=$ac_cv_path_HEAD
7454 if test -n "$HEAD"; then
7455   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7456 $as_echo "$HEAD" >&6; }
7457 else
7458   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7459 $as_echo "no" >&6; }
7460 fi
7461 
7462 
7463         if test "x$HEAD" = x; then
7464           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7465         fi
7466       else
7467         # Otherwise we believe it is a complete path. Use it as it is.
7468         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
7469 $as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
7470         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
7471 $as_echo_n "checking for HEAD... " >&6; }
7472         if test ! -x "$tool_specified"; then
7473           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7474 $as_echo "not found" >&6; }
7475           as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
7476         fi
7477         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7478 $as_echo "$tool_specified" >&6; }
7479       fi
7480     fi
7481   fi
7482 
7483 
7484 
7485   if test "x$HEAD" = x; then
7486     as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
7487   fi
7488 
7489 
7490 
7491 
7492 
7493   # Publish this variable in the help.
7494 
7495 
7496   if test "x$LN" = x; then
7497     # The variable is not set by user, try to locate tool using the code snippet
7498     for ac_prog in ln
7499 do
7500   # Extract the first word of "$ac_prog", so it can be a program name with args.
7501 set dummy $ac_prog; ac_word=$2
7502 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7503 $as_echo_n "checking for $ac_word... " >&6; }
7504 if ${ac_cv_path_LN+:} false; then :
7505   $as_echo_n "(cached) " >&6
7506 else
7507   case $LN in
7508   [\\/]* | ?:[\\/]*)
7509   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7510   ;;
7511   *)
7512   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7513 for as_dir in $PATH
7514 do
7515   IFS=$as_save_IFS
7516   test -z "$as_dir" && as_dir=.
7517     for ac_exec_ext in '' $ac_executable_extensions; do
7518   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7519     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7520     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7521     break 2
7522   fi
7523 done
7524   done
7525 IFS=$as_save_IFS
7526 
7527   ;;
7528 esac
7529 fi
7530 LN=$ac_cv_path_LN
7531 if test -n "$LN"; then
7532   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7533 $as_echo "$LN" >&6; }
7534 else
7535   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7536 $as_echo "no" >&6; }
7537 fi
7538 
7539 
7540   test -n "$LN" && break
7541 done
7542 
7543   else
7544     # The variable is set, but is it from the command line or the environment?
7545 
7546     # Try to remove the string !LN! from our list.
7547     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
7548     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7549       # If it failed, the variable was not from the command line. Ignore it,
7550       # but warn the user (except for BASH, which is always set by the calling BASH).
7551       if test "xLN" != xBASH; then
7552         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
7553 $as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
7554       fi
7555       # Try to locate tool using the code snippet
7556       for ac_prog in ln
7557 do
7558   # Extract the first word of "$ac_prog", so it can be a program name with args.
7559 set dummy $ac_prog; ac_word=$2
7560 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7561 $as_echo_n "checking for $ac_word... " >&6; }
7562 if ${ac_cv_path_LN+:} false; then :
7563   $as_echo_n "(cached) " >&6
7564 else
7565   case $LN in
7566   [\\/]* | ?:[\\/]*)
7567   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7568   ;;
7569   *)
7570   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7571 for as_dir in $PATH
7572 do
7573   IFS=$as_save_IFS
7574   test -z "$as_dir" && as_dir=.
7575     for ac_exec_ext in '' $ac_executable_extensions; do
7576   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7577     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7578     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7579     break 2
7580   fi
7581 done
7582   done
7583 IFS=$as_save_IFS
7584 
7585   ;;
7586 esac
7587 fi
7588 LN=$ac_cv_path_LN
7589 if test -n "$LN"; then
7590   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7591 $as_echo "$LN" >&6; }
7592 else
7593   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7594 $as_echo "no" >&6; }
7595 fi
7596 
7597 
7598   test -n "$LN" && break
7599 done
7600 
7601     else
7602       # If it succeeded, then it was overridden by the user. We will use it
7603       # for the tool.
7604 
7605       # First remove it from the list of overridden variables, so we can test
7606       # for unknown variables in the end.
7607       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7608 
7609       # Check if the provided tool contains a complete path.
7610       tool_specified="$LN"
7611       tool_basename="${tool_specified##*/}"
7612       if test "x$tool_basename" = "x$tool_specified"; then
7613         # A command without a complete path is provided, search $PATH.
7614         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
7615 $as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
7616         # Extract the first word of "$tool_basename", so it can be a program name with args.
7617 set dummy $tool_basename; ac_word=$2
7618 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7619 $as_echo_n "checking for $ac_word... " >&6; }
7620 if ${ac_cv_path_LN+:} false; then :
7621   $as_echo_n "(cached) " >&6
7622 else
7623   case $LN in
7624   [\\/]* | ?:[\\/]*)
7625   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7626   ;;
7627   *)
7628   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7629 for as_dir in $PATH
7630 do
7631   IFS=$as_save_IFS
7632   test -z "$as_dir" && as_dir=.
7633     for ac_exec_ext in '' $ac_executable_extensions; do
7634   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7635     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7636     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7637     break 2
7638   fi
7639 done
7640   done
7641 IFS=$as_save_IFS
7642 
7643   ;;
7644 esac
7645 fi
7646 LN=$ac_cv_path_LN
7647 if test -n "$LN"; then
7648   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7649 $as_echo "$LN" >&6; }
7650 else
7651   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7652 $as_echo "no" >&6; }
7653 fi
7654 
7655 
7656         if test "x$LN" = x; then
7657           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7658         fi
7659       else
7660         # Otherwise we believe it is a complete path. Use it as it is.
7661         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
7662 $as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
7663         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
7664 $as_echo_n "checking for LN... " >&6; }
7665         if test ! -x "$tool_specified"; then
7666           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7667 $as_echo "not found" >&6; }
7668           as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
7669         fi
7670         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7671 $as_echo "$tool_specified" >&6; }
7672       fi
7673     fi
7674   fi
7675 
7676 
7677 
7678   if test "x$LN" = x; then
7679     as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
7680   fi
7681 
7682 
7683 
7684 
7685 
7686   # Publish this variable in the help.
7687 
7688 
7689   if test "x$LS" = x; then
7690     # The variable is not set by user, try to locate tool using the code snippet
7691     for ac_prog in ls
7692 do
7693   # Extract the first word of "$ac_prog", so it can be a program name with args.
7694 set dummy $ac_prog; ac_word=$2
7695 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7696 $as_echo_n "checking for $ac_word... " >&6; }
7697 if ${ac_cv_path_LS+:} false; then :
7698   $as_echo_n "(cached) " >&6
7699 else
7700   case $LS in
7701   [\\/]* | ?:[\\/]*)
7702   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7703   ;;
7704   *)
7705   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7706 for as_dir in $PATH
7707 do
7708   IFS=$as_save_IFS
7709   test -z "$as_dir" && as_dir=.
7710     for ac_exec_ext in '' $ac_executable_extensions; do
7711   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7712     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7713     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7714     break 2
7715   fi
7716 done
7717   done
7718 IFS=$as_save_IFS
7719 
7720   ;;
7721 esac
7722 fi
7723 LS=$ac_cv_path_LS
7724 if test -n "$LS"; then
7725   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7726 $as_echo "$LS" >&6; }
7727 else
7728   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7729 $as_echo "no" >&6; }
7730 fi
7731 
7732 
7733   test -n "$LS" && break
7734 done
7735 
7736   else
7737     # The variable is set, but is it from the command line or the environment?
7738 
7739     # Try to remove the string !LS! from our list.
7740     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
7741     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7742       # If it failed, the variable was not from the command line. Ignore it,
7743       # but warn the user (except for BASH, which is always set by the calling BASH).
7744       if test "xLS" != xBASH; then
7745         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
7746 $as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
7747       fi
7748       # Try to locate tool using the code snippet
7749       for ac_prog in ls
7750 do
7751   # Extract the first word of "$ac_prog", so it can be a program name with args.
7752 set dummy $ac_prog; ac_word=$2
7753 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7754 $as_echo_n "checking for $ac_word... " >&6; }
7755 if ${ac_cv_path_LS+:} false; then :
7756   $as_echo_n "(cached) " >&6
7757 else
7758   case $LS in
7759   [\\/]* | ?:[\\/]*)
7760   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7761   ;;
7762   *)
7763   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7764 for as_dir in $PATH
7765 do
7766   IFS=$as_save_IFS
7767   test -z "$as_dir" && as_dir=.
7768     for ac_exec_ext in '' $ac_executable_extensions; do
7769   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7770     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7771     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7772     break 2
7773   fi
7774 done
7775   done
7776 IFS=$as_save_IFS
7777 
7778   ;;
7779 esac
7780 fi
7781 LS=$ac_cv_path_LS
7782 if test -n "$LS"; then
7783   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7784 $as_echo "$LS" >&6; }
7785 else
7786   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7787 $as_echo "no" >&6; }
7788 fi
7789 
7790 
7791   test -n "$LS" && break
7792 done
7793 
7794     else
7795       # If it succeeded, then it was overridden by the user. We will use it
7796       # for the tool.
7797 
7798       # First remove it from the list of overridden variables, so we can test
7799       # for unknown variables in the end.
7800       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7801 
7802       # Check if the provided tool contains a complete path.
7803       tool_specified="$LS"
7804       tool_basename="${tool_specified##*/}"
7805       if test "x$tool_basename" = "x$tool_specified"; then
7806         # A command without a complete path is provided, search $PATH.
7807         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
7808 $as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
7809         # Extract the first word of "$tool_basename", so it can be a program name with args.
7810 set dummy $tool_basename; ac_word=$2
7811 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7812 $as_echo_n "checking for $ac_word... " >&6; }
7813 if ${ac_cv_path_LS+:} false; then :
7814   $as_echo_n "(cached) " >&6
7815 else
7816   case $LS in
7817   [\\/]* | ?:[\\/]*)
7818   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7819   ;;
7820   *)
7821   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7822 for as_dir in $PATH
7823 do
7824   IFS=$as_save_IFS
7825   test -z "$as_dir" && as_dir=.
7826     for ac_exec_ext in '' $ac_executable_extensions; do
7827   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7828     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7829     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7830     break 2
7831   fi
7832 done
7833   done
7834 IFS=$as_save_IFS
7835 
7836   ;;
7837 esac
7838 fi
7839 LS=$ac_cv_path_LS
7840 if test -n "$LS"; then
7841   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7842 $as_echo "$LS" >&6; }
7843 else
7844   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7845 $as_echo "no" >&6; }
7846 fi
7847 
7848 
7849         if test "x$LS" = x; then
7850           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7851         fi
7852       else
7853         # Otherwise we believe it is a complete path. Use it as it is.
7854         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
7855 $as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
7856         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
7857 $as_echo_n "checking for LS... " >&6; }
7858         if test ! -x "$tool_specified"; then
7859           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7860 $as_echo "not found" >&6; }
7861           as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
7862         fi
7863         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7864 $as_echo "$tool_specified" >&6; }
7865       fi
7866     fi
7867   fi
7868 
7869 
7870 
7871   if test "x$LS" = x; then
7872     as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
7873   fi
7874 
7875 
7876 
7877 
7878 
7879   # Publish this variable in the help.
7880 
7881 
7882   if test "x$MKDIR" = x; then
7883     # The variable is not set by user, try to locate tool using the code snippet
7884     for ac_prog in mkdir
7885 do
7886   # Extract the first word of "$ac_prog", so it can be a program name with args.
7887 set dummy $ac_prog; ac_word=$2
7888 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7889 $as_echo_n "checking for $ac_word... " >&6; }
7890 if ${ac_cv_path_MKDIR+:} false; then :
7891   $as_echo_n "(cached) " >&6
7892 else
7893   case $MKDIR in
7894   [\\/]* | ?:[\\/]*)
7895   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7896   ;;
7897   *)
7898   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7899 for as_dir in $PATH
7900 do
7901   IFS=$as_save_IFS
7902   test -z "$as_dir" && as_dir=.
7903     for ac_exec_ext in '' $ac_executable_extensions; do
7904   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7905     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7906     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7907     break 2
7908   fi
7909 done
7910   done
7911 IFS=$as_save_IFS
7912 
7913   ;;
7914 esac
7915 fi
7916 MKDIR=$ac_cv_path_MKDIR
7917 if test -n "$MKDIR"; then
7918   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
7919 $as_echo "$MKDIR" >&6; }
7920 else
7921   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7922 $as_echo "no" >&6; }
7923 fi
7924 
7925 
7926   test -n "$MKDIR" && break
7927 done
7928 
7929   else
7930     # The variable is set, but is it from the command line or the environment?
7931 
7932     # Try to remove the string !MKDIR! from our list.
7933     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
7934     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7935       # If it failed, the variable was not from the command line. Ignore it,
7936       # but warn the user (except for BASH, which is always set by the calling BASH).
7937       if test "xMKDIR" != xBASH; then
7938         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
7939 $as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
7940       fi
7941       # Try to locate tool using the code snippet
7942       for ac_prog in mkdir
7943 do
7944   # Extract the first word of "$ac_prog", so it can be a program name with args.
7945 set dummy $ac_prog; ac_word=$2
7946 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7947 $as_echo_n "checking for $ac_word... " >&6; }
7948 if ${ac_cv_path_MKDIR+:} false; then :
7949   $as_echo_n "(cached) " >&6
7950 else
7951   case $MKDIR in
7952   [\\/]* | ?:[\\/]*)
7953   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7954   ;;
7955   *)
7956   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7957 for as_dir in $PATH
7958 do
7959   IFS=$as_save_IFS
7960   test -z "$as_dir" && as_dir=.
7961     for ac_exec_ext in '' $ac_executable_extensions; do
7962   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7963     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7964     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7965     break 2
7966   fi
7967 done
7968   done
7969 IFS=$as_save_IFS
7970 
7971   ;;
7972 esac
7973 fi
7974 MKDIR=$ac_cv_path_MKDIR
7975 if test -n "$MKDIR"; then
7976   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
7977 $as_echo "$MKDIR" >&6; }
7978 else
7979   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7980 $as_echo "no" >&6; }
7981 fi
7982 
7983 
7984   test -n "$MKDIR" && break
7985 done
7986 
7987     else
7988       # If it succeeded, then it was overridden by the user. We will use it
7989       # for the tool.
7990 
7991       # First remove it from the list of overridden variables, so we can test
7992       # for unknown variables in the end.
7993       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7994 
7995       # Check if the provided tool contains a complete path.
7996       tool_specified="$MKDIR"
7997       tool_basename="${tool_specified##*/}"
7998       if test "x$tool_basename" = "x$tool_specified"; then
7999         # A command without a complete path is provided, search $PATH.
8000         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
8001 $as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
8002         # Extract the first word of "$tool_basename", so it can be a program name with args.
8003 set dummy $tool_basename; ac_word=$2
8004 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8005 $as_echo_n "checking for $ac_word... " >&6; }
8006 if ${ac_cv_path_MKDIR+:} false; then :
8007   $as_echo_n "(cached) " >&6
8008 else
8009   case $MKDIR in
8010   [\\/]* | ?:[\\/]*)
8011   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8012   ;;
8013   *)
8014   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8015 for as_dir in $PATH
8016 do
8017   IFS=$as_save_IFS
8018   test -z "$as_dir" && as_dir=.
8019     for ac_exec_ext in '' $ac_executable_extensions; do
8020   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8021     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8022     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8023     break 2
8024   fi
8025 done
8026   done
8027 IFS=$as_save_IFS
8028 
8029   ;;
8030 esac
8031 fi
8032 MKDIR=$ac_cv_path_MKDIR
8033 if test -n "$MKDIR"; then
8034   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8035 $as_echo "$MKDIR" >&6; }
8036 else
8037   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8038 $as_echo "no" >&6; }
8039 fi
8040 
8041 
8042         if test "x$MKDIR" = x; then
8043           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8044         fi
8045       else
8046         # Otherwise we believe it is a complete path. Use it as it is.
8047         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
8048 $as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
8049         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
8050 $as_echo_n "checking for MKDIR... " >&6; }
8051         if test ! -x "$tool_specified"; then
8052           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8053 $as_echo "not found" >&6; }
8054           as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
8055         fi
8056         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8057 $as_echo "$tool_specified" >&6; }
8058       fi
8059     fi
8060   fi
8061 
8062 
8063 
8064   if test "x$MKDIR" = x; then
8065     as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
8066   fi
8067 
8068 
8069 
8070 
8071 
8072   # Publish this variable in the help.
8073 
8074 
8075   if test "x$MKTEMP" = x; then
8076     # The variable is not set by user, try to locate tool using the code snippet
8077     for ac_prog in mktemp
8078 do
8079   # Extract the first word of "$ac_prog", so it can be a program name with args.
8080 set dummy $ac_prog; ac_word=$2
8081 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8082 $as_echo_n "checking for $ac_word... " >&6; }
8083 if ${ac_cv_path_MKTEMP+:} false; then :
8084   $as_echo_n "(cached) " >&6
8085 else
8086   case $MKTEMP in
8087   [\\/]* | ?:[\\/]*)
8088   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8089   ;;
8090   *)
8091   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8092 for as_dir in $PATH
8093 do
8094   IFS=$as_save_IFS
8095   test -z "$as_dir" && as_dir=.
8096     for ac_exec_ext in '' $ac_executable_extensions; do
8097   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8098     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8099     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8100     break 2
8101   fi
8102 done
8103   done
8104 IFS=$as_save_IFS
8105 
8106   ;;
8107 esac
8108 fi
8109 MKTEMP=$ac_cv_path_MKTEMP
8110 if test -n "$MKTEMP"; then
8111   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8112 $as_echo "$MKTEMP" >&6; }
8113 else
8114   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8115 $as_echo "no" >&6; }
8116 fi
8117 
8118 
8119   test -n "$MKTEMP" && break
8120 done
8121 
8122   else
8123     # The variable is set, but is it from the command line or the environment?
8124 
8125     # Try to remove the string !MKTEMP! from our list.
8126     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
8127     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8128       # If it failed, the variable was not from the command line. Ignore it,
8129       # but warn the user (except for BASH, which is always set by the calling BASH).
8130       if test "xMKTEMP" != xBASH; then
8131         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
8132 $as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
8133       fi
8134       # Try to locate tool using the code snippet
8135       for ac_prog in mktemp
8136 do
8137   # Extract the first word of "$ac_prog", so it can be a program name with args.
8138 set dummy $ac_prog; ac_word=$2
8139 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8140 $as_echo_n "checking for $ac_word... " >&6; }
8141 if ${ac_cv_path_MKTEMP+:} false; then :
8142   $as_echo_n "(cached) " >&6
8143 else
8144   case $MKTEMP in
8145   [\\/]* | ?:[\\/]*)
8146   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8147   ;;
8148   *)
8149   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8150 for as_dir in $PATH
8151 do
8152   IFS=$as_save_IFS
8153   test -z "$as_dir" && as_dir=.
8154     for ac_exec_ext in '' $ac_executable_extensions; do
8155   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8156     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8157     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8158     break 2
8159   fi
8160 done
8161   done
8162 IFS=$as_save_IFS
8163 
8164   ;;
8165 esac
8166 fi
8167 MKTEMP=$ac_cv_path_MKTEMP
8168 if test -n "$MKTEMP"; then
8169   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8170 $as_echo "$MKTEMP" >&6; }
8171 else
8172   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8173 $as_echo "no" >&6; }
8174 fi
8175 
8176 
8177   test -n "$MKTEMP" && break
8178 done
8179 
8180     else
8181       # If it succeeded, then it was overridden by the user. We will use it
8182       # for the tool.
8183 
8184       # First remove it from the list of overridden variables, so we can test
8185       # for unknown variables in the end.
8186       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8187 
8188       # Check if the provided tool contains a complete path.
8189       tool_specified="$MKTEMP"
8190       tool_basename="${tool_specified##*/}"
8191       if test "x$tool_basename" = "x$tool_specified"; then
8192         # A command without a complete path is provided, search $PATH.
8193         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
8194 $as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
8195         # Extract the first word of "$tool_basename", so it can be a program name with args.
8196 set dummy $tool_basename; ac_word=$2
8197 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8198 $as_echo_n "checking for $ac_word... " >&6; }
8199 if ${ac_cv_path_MKTEMP+:} false; then :
8200   $as_echo_n "(cached) " >&6
8201 else
8202   case $MKTEMP in
8203   [\\/]* | ?:[\\/]*)
8204   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8205   ;;
8206   *)
8207   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8208 for as_dir in $PATH
8209 do
8210   IFS=$as_save_IFS
8211   test -z "$as_dir" && as_dir=.
8212     for ac_exec_ext in '' $ac_executable_extensions; do
8213   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8214     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8215     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8216     break 2
8217   fi
8218 done
8219   done
8220 IFS=$as_save_IFS
8221 
8222   ;;
8223 esac
8224 fi
8225 MKTEMP=$ac_cv_path_MKTEMP
8226 if test -n "$MKTEMP"; then
8227   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8228 $as_echo "$MKTEMP" >&6; }
8229 else
8230   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8231 $as_echo "no" >&6; }
8232 fi
8233 
8234 
8235         if test "x$MKTEMP" = x; then
8236           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8237         fi
8238       else
8239         # Otherwise we believe it is a complete path. Use it as it is.
8240         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
8241 $as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
8242         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
8243 $as_echo_n "checking for MKTEMP... " >&6; }
8244         if test ! -x "$tool_specified"; then
8245           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8246 $as_echo "not found" >&6; }
8247           as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
8248         fi
8249         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8250 $as_echo "$tool_specified" >&6; }
8251       fi
8252     fi
8253   fi
8254 
8255 
8256 
8257   if test "x$MKTEMP" = x; then
8258     as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
8259   fi
8260 
8261 
8262 
8263 
8264 
8265   # Publish this variable in the help.
8266 
8267 
8268   if test "x$MV" = x; then
8269     # The variable is not set by user, try to locate tool using the code snippet
8270     for ac_prog in mv
8271 do
8272   # Extract the first word of "$ac_prog", so it can be a program name with args.
8273 set dummy $ac_prog; ac_word=$2
8274 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8275 $as_echo_n "checking for $ac_word... " >&6; }
8276 if ${ac_cv_path_MV+:} false; then :
8277   $as_echo_n "(cached) " >&6
8278 else
8279   case $MV in
8280   [\\/]* | ?:[\\/]*)
8281   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8282   ;;
8283   *)
8284   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8285 for as_dir in $PATH
8286 do
8287   IFS=$as_save_IFS
8288   test -z "$as_dir" && as_dir=.
8289     for ac_exec_ext in '' $ac_executable_extensions; do
8290   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8291     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8292     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8293     break 2
8294   fi
8295 done
8296   done
8297 IFS=$as_save_IFS
8298 
8299   ;;
8300 esac
8301 fi
8302 MV=$ac_cv_path_MV
8303 if test -n "$MV"; then
8304   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8305 $as_echo "$MV" >&6; }
8306 else
8307   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8308 $as_echo "no" >&6; }
8309 fi
8310 
8311 
8312   test -n "$MV" && break
8313 done
8314 
8315   else
8316     # The variable is set, but is it from the command line or the environment?
8317 
8318     # Try to remove the string !MV! from our list.
8319     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
8320     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8321       # If it failed, the variable was not from the command line. Ignore it,
8322       # but warn the user (except for BASH, which is always set by the calling BASH).
8323       if test "xMV" != xBASH; then
8324         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
8325 $as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
8326       fi
8327       # Try to locate tool using the code snippet
8328       for ac_prog in mv
8329 do
8330   # Extract the first word of "$ac_prog", so it can be a program name with args.
8331 set dummy $ac_prog; ac_word=$2
8332 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8333 $as_echo_n "checking for $ac_word... " >&6; }
8334 if ${ac_cv_path_MV+:} false; then :
8335   $as_echo_n "(cached) " >&6
8336 else
8337   case $MV in
8338   [\\/]* | ?:[\\/]*)
8339   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8340   ;;
8341   *)
8342   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8343 for as_dir in $PATH
8344 do
8345   IFS=$as_save_IFS
8346   test -z "$as_dir" && as_dir=.
8347     for ac_exec_ext in '' $ac_executable_extensions; do
8348   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8349     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8350     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8351     break 2
8352   fi
8353 done
8354   done
8355 IFS=$as_save_IFS
8356 
8357   ;;
8358 esac
8359 fi
8360 MV=$ac_cv_path_MV
8361 if test -n "$MV"; then
8362   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8363 $as_echo "$MV" >&6; }
8364 else
8365   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8366 $as_echo "no" >&6; }
8367 fi
8368 
8369 
8370   test -n "$MV" && break
8371 done
8372 
8373     else
8374       # If it succeeded, then it was overridden by the user. We will use it
8375       # for the tool.
8376 
8377       # First remove it from the list of overridden variables, so we can test
8378       # for unknown variables in the end.
8379       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8380 
8381       # Check if the provided tool contains a complete path.
8382       tool_specified="$MV"
8383       tool_basename="${tool_specified##*/}"
8384       if test "x$tool_basename" = "x$tool_specified"; then
8385         # A command without a complete path is provided, search $PATH.
8386         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
8387 $as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
8388         # Extract the first word of "$tool_basename", so it can be a program name with args.
8389 set dummy $tool_basename; ac_word=$2
8390 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8391 $as_echo_n "checking for $ac_word... " >&6; }
8392 if ${ac_cv_path_MV+:} false; then :
8393   $as_echo_n "(cached) " >&6
8394 else
8395   case $MV in
8396   [\\/]* | ?:[\\/]*)
8397   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8398   ;;
8399   *)
8400   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8401 for as_dir in $PATH
8402 do
8403   IFS=$as_save_IFS
8404   test -z "$as_dir" && as_dir=.
8405     for ac_exec_ext in '' $ac_executable_extensions; do
8406   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8407     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8408     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8409     break 2
8410   fi
8411 done
8412   done
8413 IFS=$as_save_IFS
8414 
8415   ;;
8416 esac
8417 fi
8418 MV=$ac_cv_path_MV
8419 if test -n "$MV"; then
8420   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8421 $as_echo "$MV" >&6; }
8422 else
8423   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8424 $as_echo "no" >&6; }
8425 fi
8426 
8427 
8428         if test "x$MV" = x; then
8429           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8430         fi
8431       else
8432         # Otherwise we believe it is a complete path. Use it as it is.
8433         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
8434 $as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
8435         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
8436 $as_echo_n "checking for MV... " >&6; }
8437         if test ! -x "$tool_specified"; then
8438           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8439 $as_echo "not found" >&6; }
8440           as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
8441         fi
8442         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8443 $as_echo "$tool_specified" >&6; }
8444       fi
8445     fi
8446   fi
8447 
8448 
8449 
8450   if test "x$MV" = x; then
8451     as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
8452   fi
8453 
8454 
8455 
8456 
8457 
8458   # Publish this variable in the help.
8459 
8460 
8461   if test "x$NAWK" = x; then
8462     # The variable is not set by user, try to locate tool using the code snippet
8463     for ac_prog in nawk gawk awk
8464 do
8465   # Extract the first word of "$ac_prog", so it can be a program name with args.
8466 set dummy $ac_prog; ac_word=$2
8467 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8468 $as_echo_n "checking for $ac_word... " >&6; }
8469 if ${ac_cv_path_NAWK+:} false; then :
8470   $as_echo_n "(cached) " >&6
8471 else
8472   case $NAWK in
8473   [\\/]* | ?:[\\/]*)
8474   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8475   ;;
8476   *)
8477   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8478 for as_dir in $PATH
8479 do
8480   IFS=$as_save_IFS
8481   test -z "$as_dir" && as_dir=.
8482     for ac_exec_ext in '' $ac_executable_extensions; do
8483   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8484     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8485     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8486     break 2
8487   fi
8488 done
8489   done
8490 IFS=$as_save_IFS
8491 
8492   ;;
8493 esac
8494 fi
8495 NAWK=$ac_cv_path_NAWK
8496 if test -n "$NAWK"; then
8497   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8498 $as_echo "$NAWK" >&6; }
8499 else
8500   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8501 $as_echo "no" >&6; }
8502 fi
8503 
8504 
8505   test -n "$NAWK" && break
8506 done
8507 
8508   else
8509     # The variable is set, but is it from the command line or the environment?
8510 
8511     # Try to remove the string !NAWK! from our list.
8512     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
8513     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8514       # If it failed, the variable was not from the command line. Ignore it,
8515       # but warn the user (except for BASH, which is always set by the calling BASH).
8516       if test "xNAWK" != xBASH; then
8517         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
8518 $as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
8519       fi
8520       # Try to locate tool using the code snippet
8521       for ac_prog in nawk gawk awk
8522 do
8523   # Extract the first word of "$ac_prog", so it can be a program name with args.
8524 set dummy $ac_prog; ac_word=$2
8525 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8526 $as_echo_n "checking for $ac_word... " >&6; }
8527 if ${ac_cv_path_NAWK+:} false; then :
8528   $as_echo_n "(cached) " >&6
8529 else
8530   case $NAWK in
8531   [\\/]* | ?:[\\/]*)
8532   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8533   ;;
8534   *)
8535   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8536 for as_dir in $PATH
8537 do
8538   IFS=$as_save_IFS
8539   test -z "$as_dir" && as_dir=.
8540     for ac_exec_ext in '' $ac_executable_extensions; do
8541   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8542     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8543     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8544     break 2
8545   fi
8546 done
8547   done
8548 IFS=$as_save_IFS
8549 
8550   ;;
8551 esac
8552 fi
8553 NAWK=$ac_cv_path_NAWK
8554 if test -n "$NAWK"; then
8555   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8556 $as_echo "$NAWK" >&6; }
8557 else
8558   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8559 $as_echo "no" >&6; }
8560 fi
8561 
8562 
8563   test -n "$NAWK" && break
8564 done
8565 
8566     else
8567       # If it succeeded, then it was overridden by the user. We will use it
8568       # for the tool.
8569 
8570       # First remove it from the list of overridden variables, so we can test
8571       # for unknown variables in the end.
8572       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8573 
8574       # Check if the provided tool contains a complete path.
8575       tool_specified="$NAWK"
8576       tool_basename="${tool_specified##*/}"
8577       if test "x$tool_basename" = "x$tool_specified"; then
8578         # A command without a complete path is provided, search $PATH.
8579         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
8580 $as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
8581         # Extract the first word of "$tool_basename", so it can be a program name with args.
8582 set dummy $tool_basename; ac_word=$2
8583 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8584 $as_echo_n "checking for $ac_word... " >&6; }
8585 if ${ac_cv_path_NAWK+:} false; then :
8586   $as_echo_n "(cached) " >&6
8587 else
8588   case $NAWK in
8589   [\\/]* | ?:[\\/]*)
8590   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8591   ;;
8592   *)
8593   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8594 for as_dir in $PATH
8595 do
8596   IFS=$as_save_IFS
8597   test -z "$as_dir" && as_dir=.
8598     for ac_exec_ext in '' $ac_executable_extensions; do
8599   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8600     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8601     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8602     break 2
8603   fi
8604 done
8605   done
8606 IFS=$as_save_IFS
8607 
8608   ;;
8609 esac
8610 fi
8611 NAWK=$ac_cv_path_NAWK
8612 if test -n "$NAWK"; then
8613   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8614 $as_echo "$NAWK" >&6; }
8615 else
8616   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8617 $as_echo "no" >&6; }
8618 fi
8619 
8620 
8621         if test "x$NAWK" = x; then
8622           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8623         fi
8624       else
8625         # Otherwise we believe it is a complete path. Use it as it is.
8626         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
8627 $as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
8628         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
8629 $as_echo_n "checking for NAWK... " >&6; }
8630         if test ! -x "$tool_specified"; then
8631           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8632 $as_echo "not found" >&6; }
8633           as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
8634         fi
8635         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8636 $as_echo "$tool_specified" >&6; }
8637       fi
8638     fi
8639   fi
8640 
8641 
8642 
8643   if test "x$NAWK" = x; then
8644     as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
8645   fi
8646 
8647 
8648 
8649 
8650 
8651   # Publish this variable in the help.
8652 
8653 
8654   if test "x$PRINTF" = x; then
8655     # The variable is not set by user, try to locate tool using the code snippet
8656     for ac_prog in printf
8657 do
8658   # Extract the first word of "$ac_prog", so it can be a program name with args.
8659 set dummy $ac_prog; ac_word=$2
8660 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8661 $as_echo_n "checking for $ac_word... " >&6; }
8662 if ${ac_cv_path_PRINTF+:} false; then :
8663   $as_echo_n "(cached) " >&6
8664 else
8665   case $PRINTF in
8666   [\\/]* | ?:[\\/]*)
8667   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8668   ;;
8669   *)
8670   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8671 for as_dir in $PATH
8672 do
8673   IFS=$as_save_IFS
8674   test -z "$as_dir" && as_dir=.
8675     for ac_exec_ext in '' $ac_executable_extensions; do
8676   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8677     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8678     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8679     break 2
8680   fi
8681 done
8682   done
8683 IFS=$as_save_IFS
8684 
8685   ;;
8686 esac
8687 fi
8688 PRINTF=$ac_cv_path_PRINTF
8689 if test -n "$PRINTF"; then
8690   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8691 $as_echo "$PRINTF" >&6; }
8692 else
8693   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8694 $as_echo "no" >&6; }
8695 fi
8696 
8697 
8698   test -n "$PRINTF" && break
8699 done
8700 
8701   else
8702     # The variable is set, but is it from the command line or the environment?
8703 
8704     # Try to remove the string !PRINTF! from our list.
8705     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
8706     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8707       # If it failed, the variable was not from the command line. Ignore it,
8708       # but warn the user (except for BASH, which is always set by the calling BASH).
8709       if test "xPRINTF" != xBASH; then
8710         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
8711 $as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
8712       fi
8713       # Try to locate tool using the code snippet
8714       for ac_prog in printf
8715 do
8716   # Extract the first word of "$ac_prog", so it can be a program name with args.
8717 set dummy $ac_prog; ac_word=$2
8718 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8719 $as_echo_n "checking for $ac_word... " >&6; }
8720 if ${ac_cv_path_PRINTF+:} false; then :
8721   $as_echo_n "(cached) " >&6
8722 else
8723   case $PRINTF in
8724   [\\/]* | ?:[\\/]*)
8725   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8726   ;;
8727   *)
8728   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8729 for as_dir in $PATH
8730 do
8731   IFS=$as_save_IFS
8732   test -z "$as_dir" && as_dir=.
8733     for ac_exec_ext in '' $ac_executable_extensions; do
8734   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8735     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8736     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8737     break 2
8738   fi
8739 done
8740   done
8741 IFS=$as_save_IFS
8742 
8743   ;;
8744 esac
8745 fi
8746 PRINTF=$ac_cv_path_PRINTF
8747 if test -n "$PRINTF"; then
8748   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8749 $as_echo "$PRINTF" >&6; }
8750 else
8751   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8752 $as_echo "no" >&6; }
8753 fi
8754 
8755 
8756   test -n "$PRINTF" && break
8757 done
8758 
8759     else
8760       # If it succeeded, then it was overridden by the user. We will use it
8761       # for the tool.
8762 
8763       # First remove it from the list of overridden variables, so we can test
8764       # for unknown variables in the end.
8765       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8766 
8767       # Check if the provided tool contains a complete path.
8768       tool_specified="$PRINTF"
8769       tool_basename="${tool_specified##*/}"
8770       if test "x$tool_basename" = "x$tool_specified"; then
8771         # A command without a complete path is provided, search $PATH.
8772         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
8773 $as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
8774         # Extract the first word of "$tool_basename", so it can be a program name with args.
8775 set dummy $tool_basename; ac_word=$2
8776 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8777 $as_echo_n "checking for $ac_word... " >&6; }
8778 if ${ac_cv_path_PRINTF+:} false; then :
8779   $as_echo_n "(cached) " >&6
8780 else
8781   case $PRINTF in
8782   [\\/]* | ?:[\\/]*)
8783   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8784   ;;
8785   *)
8786   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8787 for as_dir in $PATH
8788 do
8789   IFS=$as_save_IFS
8790   test -z "$as_dir" && as_dir=.
8791     for ac_exec_ext in '' $ac_executable_extensions; do
8792   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8793     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8794     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8795     break 2
8796   fi
8797 done
8798   done
8799 IFS=$as_save_IFS
8800 
8801   ;;
8802 esac
8803 fi
8804 PRINTF=$ac_cv_path_PRINTF
8805 if test -n "$PRINTF"; then
8806   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8807 $as_echo "$PRINTF" >&6; }
8808 else
8809   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8810 $as_echo "no" >&6; }
8811 fi
8812 
8813 
8814         if test "x$PRINTF" = x; then
8815           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8816         fi
8817       else
8818         # Otherwise we believe it is a complete path. Use it as it is.
8819         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
8820 $as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
8821         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
8822 $as_echo_n "checking for PRINTF... " >&6; }
8823         if test ! -x "$tool_specified"; then
8824           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8825 $as_echo "not found" >&6; }
8826           as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
8827         fi
8828         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8829 $as_echo "$tool_specified" >&6; }
8830       fi
8831     fi
8832   fi
8833 
8834 
8835 
8836   if test "x$PRINTF" = x; then
8837     as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
8838   fi
8839 
8840 
8841 
8842 
8843 
8844   # Publish this variable in the help.
8845 
8846 
8847   if test "x$RM" = x; then
8848     # The variable is not set by user, try to locate tool using the code snippet
8849     for ac_prog in rm
8850 do
8851   # Extract the first word of "$ac_prog", so it can be a program name with args.
8852 set dummy $ac_prog; ac_word=$2
8853 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8854 $as_echo_n "checking for $ac_word... " >&6; }
8855 if ${ac_cv_path_RM+:} false; then :
8856   $as_echo_n "(cached) " >&6
8857 else
8858   case $RM in
8859   [\\/]* | ?:[\\/]*)
8860   ac_cv_path_RM="$RM" # Let the user override the test with a path.
8861   ;;
8862   *)
8863   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8864 for as_dir in $PATH
8865 do
8866   IFS=$as_save_IFS
8867   test -z "$as_dir" && as_dir=.
8868     for ac_exec_ext in '' $ac_executable_extensions; do
8869   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8870     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8871     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8872     break 2
8873   fi
8874 done
8875   done
8876 IFS=$as_save_IFS
8877 
8878   ;;
8879 esac
8880 fi
8881 RM=$ac_cv_path_RM
8882 if test -n "$RM"; then
8883   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8884 $as_echo "$RM" >&6; }
8885 else
8886   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8887 $as_echo "no" >&6; }
8888 fi
8889 
8890 
8891   test -n "$RM" && break
8892 done
8893 
8894   else
8895     # The variable is set, but is it from the command line or the environment?
8896 
8897     # Try to remove the string !RM! from our list.
8898     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
8899     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8900       # If it failed, the variable was not from the command line. Ignore it,
8901       # but warn the user (except for BASH, which is always set by the calling BASH).
8902       if test "xRM" != xBASH; then
8903         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
8904 $as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
8905       fi
8906       # Try to locate tool using the code snippet
8907       for ac_prog in rm
8908 do
8909   # Extract the first word of "$ac_prog", so it can be a program name with args.
8910 set dummy $ac_prog; ac_word=$2
8911 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8912 $as_echo_n "checking for $ac_word... " >&6; }
8913 if ${ac_cv_path_RM+:} false; then :
8914   $as_echo_n "(cached) " >&6
8915 else
8916   case $RM in
8917   [\\/]* | ?:[\\/]*)
8918   ac_cv_path_RM="$RM" # Let the user override the test with a path.
8919   ;;
8920   *)
8921   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8922 for as_dir in $PATH
8923 do
8924   IFS=$as_save_IFS
8925   test -z "$as_dir" && as_dir=.
8926     for ac_exec_ext in '' $ac_executable_extensions; do
8927   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8928     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8929     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8930     break 2
8931   fi
8932 done
8933   done
8934 IFS=$as_save_IFS
8935 
8936   ;;
8937 esac
8938 fi
8939 RM=$ac_cv_path_RM
8940 if test -n "$RM"; then
8941   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8942 $as_echo "$RM" >&6; }
8943 else
8944   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8945 $as_echo "no" >&6; }
8946 fi
8947 
8948 
8949   test -n "$RM" && break
8950 done
8951 
8952     else
8953       # If it succeeded, then it was overridden by the user. We will use it
8954       # for the tool.
8955 
8956       # First remove it from the list of overridden variables, so we can test
8957       # for unknown variables in the end.
8958       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8959 
8960       # Check if the provided tool contains a complete path.
8961       tool_specified="$RM"
8962       tool_basename="${tool_specified##*/}"
8963       if test "x$tool_basename" = "x$tool_specified"; then
8964         # A command without a complete path is provided, search $PATH.
8965         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
8966 $as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
8967         # Extract the first word of "$tool_basename", so it can be a program name with args.
8968 set dummy $tool_basename; ac_word=$2
8969 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8970 $as_echo_n "checking for $ac_word... " >&6; }
8971 if ${ac_cv_path_RM+:} false; then :
8972   $as_echo_n "(cached) " >&6
8973 else
8974   case $RM in
8975   [\\/]* | ?:[\\/]*)
8976   ac_cv_path_RM="$RM" # Let the user override the test with a path.
8977   ;;
8978   *)
8979   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8980 for as_dir in $PATH
8981 do
8982   IFS=$as_save_IFS
8983   test -z "$as_dir" && as_dir=.
8984     for ac_exec_ext in '' $ac_executable_extensions; do
8985   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8986     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8987     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8988     break 2
8989   fi
8990 done
8991   done
8992 IFS=$as_save_IFS
8993 
8994   ;;
8995 esac
8996 fi
8997 RM=$ac_cv_path_RM
8998 if test -n "$RM"; then
8999   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9000 $as_echo "$RM" >&6; }
9001 else
9002   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9003 $as_echo "no" >&6; }
9004 fi
9005 
9006 
9007         if test "x$RM" = x; then
9008           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9009         fi
9010       else
9011         # Otherwise we believe it is a complete path. Use it as it is.
9012         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
9013 $as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
9014         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
9015 $as_echo_n "checking for RM... " >&6; }
9016         if test ! -x "$tool_specified"; then
9017           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9018 $as_echo "not found" >&6; }
9019           as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
9020         fi
9021         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9022 $as_echo "$tool_specified" >&6; }
9023       fi
9024     fi
9025   fi
9026 
9027 
9028 
9029   if test "x$RM" = x; then
9030     as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
9031   fi
9032 
9033 
9034 
9035 
9036 
9037   # Publish this variable in the help.
9038 
9039 
9040   if test "x$SH" = x; then
9041     # The variable is not set by user, try to locate tool using the code snippet
9042     for ac_prog in sh
9043 do
9044   # Extract the first word of "$ac_prog", so it can be a program name with args.
9045 set dummy $ac_prog; ac_word=$2
9046 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9047 $as_echo_n "checking for $ac_word... " >&6; }
9048 if ${ac_cv_path_SH+:} false; then :
9049   $as_echo_n "(cached) " >&6
9050 else
9051   case $SH in
9052   [\\/]* | ?:[\\/]*)
9053   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9054   ;;
9055   *)
9056   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9057 for as_dir in $PATH
9058 do
9059   IFS=$as_save_IFS
9060   test -z "$as_dir" && as_dir=.
9061     for ac_exec_ext in '' $ac_executable_extensions; do
9062   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9063     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9064     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9065     break 2
9066   fi
9067 done
9068   done
9069 IFS=$as_save_IFS
9070 
9071   ;;
9072 esac
9073 fi
9074 SH=$ac_cv_path_SH
9075 if test -n "$SH"; then
9076   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9077 $as_echo "$SH" >&6; }
9078 else
9079   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9080 $as_echo "no" >&6; }
9081 fi
9082 
9083 
9084   test -n "$SH" && break
9085 done
9086 
9087   else
9088     # The variable is set, but is it from the command line or the environment?
9089 
9090     # Try to remove the string !SH! from our list.
9091     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
9092     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9093       # If it failed, the variable was not from the command line. Ignore it,
9094       # but warn the user (except for BASH, which is always set by the calling BASH).
9095       if test "xSH" != xBASH; then
9096         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
9097 $as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
9098       fi
9099       # Try to locate tool using the code snippet
9100       for ac_prog in sh
9101 do
9102   # Extract the first word of "$ac_prog", so it can be a program name with args.
9103 set dummy $ac_prog; ac_word=$2
9104 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9105 $as_echo_n "checking for $ac_word... " >&6; }
9106 if ${ac_cv_path_SH+:} false; then :
9107   $as_echo_n "(cached) " >&6
9108 else
9109   case $SH in
9110   [\\/]* | ?:[\\/]*)
9111   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9112   ;;
9113   *)
9114   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9115 for as_dir in $PATH
9116 do
9117   IFS=$as_save_IFS
9118   test -z "$as_dir" && as_dir=.
9119     for ac_exec_ext in '' $ac_executable_extensions; do
9120   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9121     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9122     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9123     break 2
9124   fi
9125 done
9126   done
9127 IFS=$as_save_IFS
9128 
9129   ;;
9130 esac
9131 fi
9132 SH=$ac_cv_path_SH
9133 if test -n "$SH"; then
9134   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9135 $as_echo "$SH" >&6; }
9136 else
9137   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9138 $as_echo "no" >&6; }
9139 fi
9140 
9141 
9142   test -n "$SH" && break
9143 done
9144 
9145     else
9146       # If it succeeded, then it was overridden by the user. We will use it
9147       # for the tool.
9148 
9149       # First remove it from the list of overridden variables, so we can test
9150       # for unknown variables in the end.
9151       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9152 
9153       # Check if the provided tool contains a complete path.
9154       tool_specified="$SH"
9155       tool_basename="${tool_specified##*/}"
9156       if test "x$tool_basename" = "x$tool_specified"; then
9157         # A command without a complete path is provided, search $PATH.
9158         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
9159 $as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
9160         # Extract the first word of "$tool_basename", so it can be a program name with args.
9161 set dummy $tool_basename; ac_word=$2
9162 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9163 $as_echo_n "checking for $ac_word... " >&6; }
9164 if ${ac_cv_path_SH+:} false; then :
9165   $as_echo_n "(cached) " >&6
9166 else
9167   case $SH in
9168   [\\/]* | ?:[\\/]*)
9169   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9170   ;;
9171   *)
9172   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9173 for as_dir in $PATH
9174 do
9175   IFS=$as_save_IFS
9176   test -z "$as_dir" && as_dir=.
9177     for ac_exec_ext in '' $ac_executable_extensions; do
9178   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9179     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9180     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9181     break 2
9182   fi
9183 done
9184   done
9185 IFS=$as_save_IFS
9186 
9187   ;;
9188 esac
9189 fi
9190 SH=$ac_cv_path_SH
9191 if test -n "$SH"; then
9192   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9193 $as_echo "$SH" >&6; }
9194 else
9195   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9196 $as_echo "no" >&6; }
9197 fi
9198 
9199 
9200         if test "x$SH" = x; then
9201           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9202         fi
9203       else
9204         # Otherwise we believe it is a complete path. Use it as it is.
9205         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
9206 $as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
9207         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
9208 $as_echo_n "checking for SH... " >&6; }
9209         if test ! -x "$tool_specified"; then
9210           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9211 $as_echo "not found" >&6; }
9212           as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
9213         fi
9214         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9215 $as_echo "$tool_specified" >&6; }
9216       fi
9217     fi
9218   fi
9219 
9220 
9221 
9222   if test "x$SH" = x; then
9223     as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
9224   fi
9225 
9226 
9227 
9228 
9229 
9230   # Publish this variable in the help.
9231 
9232 
9233   if test "x$SORT" = x; then
9234     # The variable is not set by user, try to locate tool using the code snippet
9235     for ac_prog in sort
9236 do
9237   # Extract the first word of "$ac_prog", so it can be a program name with args.
9238 set dummy $ac_prog; ac_word=$2
9239 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9240 $as_echo_n "checking for $ac_word... " >&6; }
9241 if ${ac_cv_path_SORT+:} false; then :
9242   $as_echo_n "(cached) " >&6
9243 else
9244   case $SORT in
9245   [\\/]* | ?:[\\/]*)
9246   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9247   ;;
9248   *)
9249   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9250 for as_dir in $PATH
9251 do
9252   IFS=$as_save_IFS
9253   test -z "$as_dir" && as_dir=.
9254     for ac_exec_ext in '' $ac_executable_extensions; do
9255   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9256     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9257     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9258     break 2
9259   fi
9260 done
9261   done
9262 IFS=$as_save_IFS
9263 
9264   ;;
9265 esac
9266 fi
9267 SORT=$ac_cv_path_SORT
9268 if test -n "$SORT"; then
9269   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9270 $as_echo "$SORT" >&6; }
9271 else
9272   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9273 $as_echo "no" >&6; }
9274 fi
9275 
9276 
9277   test -n "$SORT" && break
9278 done
9279 
9280   else
9281     # The variable is set, but is it from the command line or the environment?
9282 
9283     # Try to remove the string !SORT! from our list.
9284     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
9285     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9286       # If it failed, the variable was not from the command line. Ignore it,
9287       # but warn the user (except for BASH, which is always set by the calling BASH).
9288       if test "xSORT" != xBASH; then
9289         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
9290 $as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
9291       fi
9292       # Try to locate tool using the code snippet
9293       for ac_prog in sort
9294 do
9295   # Extract the first word of "$ac_prog", so it can be a program name with args.
9296 set dummy $ac_prog; ac_word=$2
9297 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9298 $as_echo_n "checking for $ac_word... " >&6; }
9299 if ${ac_cv_path_SORT+:} false; then :
9300   $as_echo_n "(cached) " >&6
9301 else
9302   case $SORT in
9303   [\\/]* | ?:[\\/]*)
9304   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9305   ;;
9306   *)
9307   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9308 for as_dir in $PATH
9309 do
9310   IFS=$as_save_IFS
9311   test -z "$as_dir" && as_dir=.
9312     for ac_exec_ext in '' $ac_executable_extensions; do
9313   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9314     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9315     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9316     break 2
9317   fi
9318 done
9319   done
9320 IFS=$as_save_IFS
9321 
9322   ;;
9323 esac
9324 fi
9325 SORT=$ac_cv_path_SORT
9326 if test -n "$SORT"; then
9327   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9328 $as_echo "$SORT" >&6; }
9329 else
9330   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9331 $as_echo "no" >&6; }
9332 fi
9333 
9334 
9335   test -n "$SORT" && break
9336 done
9337 
9338     else
9339       # If it succeeded, then it was overridden by the user. We will use it
9340       # for the tool.
9341 
9342       # First remove it from the list of overridden variables, so we can test
9343       # for unknown variables in the end.
9344       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9345 
9346       # Check if the provided tool contains a complete path.
9347       tool_specified="$SORT"
9348       tool_basename="${tool_specified##*/}"
9349       if test "x$tool_basename" = "x$tool_specified"; then
9350         # A command without a complete path is provided, search $PATH.
9351         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
9352 $as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
9353         # Extract the first word of "$tool_basename", so it can be a program name with args.
9354 set dummy $tool_basename; ac_word=$2
9355 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9356 $as_echo_n "checking for $ac_word... " >&6; }
9357 if ${ac_cv_path_SORT+:} false; then :
9358   $as_echo_n "(cached) " >&6
9359 else
9360   case $SORT in
9361   [\\/]* | ?:[\\/]*)
9362   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9363   ;;
9364   *)
9365   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9366 for as_dir in $PATH
9367 do
9368   IFS=$as_save_IFS
9369   test -z "$as_dir" && as_dir=.
9370     for ac_exec_ext in '' $ac_executable_extensions; do
9371   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9372     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9373     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9374     break 2
9375   fi
9376 done
9377   done
9378 IFS=$as_save_IFS
9379 
9380   ;;
9381 esac
9382 fi
9383 SORT=$ac_cv_path_SORT
9384 if test -n "$SORT"; then
9385   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9386 $as_echo "$SORT" >&6; }
9387 else
9388   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9389 $as_echo "no" >&6; }
9390 fi
9391 
9392 
9393         if test "x$SORT" = x; then
9394           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9395         fi
9396       else
9397         # Otherwise we believe it is a complete path. Use it as it is.
9398         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
9399 $as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
9400         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
9401 $as_echo_n "checking for SORT... " >&6; }
9402         if test ! -x "$tool_specified"; then
9403           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9404 $as_echo "not found" >&6; }
9405           as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
9406         fi
9407         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9408 $as_echo "$tool_specified" >&6; }
9409       fi
9410     fi
9411   fi
9412 
9413 
9414 
9415   if test "x$SORT" = x; then
9416     as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
9417   fi
9418 
9419 
9420 
9421 
9422 
9423   # Publish this variable in the help.
9424 
9425 
9426   if test "x$TAIL" = x; then
9427     # The variable is not set by user, try to locate tool using the code snippet
9428     for ac_prog in tail
9429 do
9430   # Extract the first word of "$ac_prog", so it can be a program name with args.
9431 set dummy $ac_prog; ac_word=$2
9432 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9433 $as_echo_n "checking for $ac_word... " >&6; }
9434 if ${ac_cv_path_TAIL+:} false; then :
9435   $as_echo_n "(cached) " >&6
9436 else
9437   case $TAIL in
9438   [\\/]* | ?:[\\/]*)
9439   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9440   ;;
9441   *)
9442   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9443 for as_dir in $PATH
9444 do
9445   IFS=$as_save_IFS
9446   test -z "$as_dir" && as_dir=.
9447     for ac_exec_ext in '' $ac_executable_extensions; do
9448   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9449     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9450     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9451     break 2
9452   fi
9453 done
9454   done
9455 IFS=$as_save_IFS
9456 
9457   ;;
9458 esac
9459 fi
9460 TAIL=$ac_cv_path_TAIL
9461 if test -n "$TAIL"; then
9462   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9463 $as_echo "$TAIL" >&6; }
9464 else
9465   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9466 $as_echo "no" >&6; }
9467 fi
9468 
9469 
9470   test -n "$TAIL" && break
9471 done
9472 
9473   else
9474     # The variable is set, but is it from the command line or the environment?
9475 
9476     # Try to remove the string !TAIL! from our list.
9477     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
9478     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9479       # If it failed, the variable was not from the command line. Ignore it,
9480       # but warn the user (except for BASH, which is always set by the calling BASH).
9481       if test "xTAIL" != xBASH; then
9482         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
9483 $as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
9484       fi
9485       # Try to locate tool using the code snippet
9486       for ac_prog in tail
9487 do
9488   # Extract the first word of "$ac_prog", so it can be a program name with args.
9489 set dummy $ac_prog; ac_word=$2
9490 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9491 $as_echo_n "checking for $ac_word... " >&6; }
9492 if ${ac_cv_path_TAIL+:} false; then :
9493   $as_echo_n "(cached) " >&6
9494 else
9495   case $TAIL in
9496   [\\/]* | ?:[\\/]*)
9497   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9498   ;;
9499   *)
9500   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9501 for as_dir in $PATH
9502 do
9503   IFS=$as_save_IFS
9504   test -z "$as_dir" && as_dir=.
9505     for ac_exec_ext in '' $ac_executable_extensions; do
9506   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9507     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9508     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9509     break 2
9510   fi
9511 done
9512   done
9513 IFS=$as_save_IFS
9514 
9515   ;;
9516 esac
9517 fi
9518 TAIL=$ac_cv_path_TAIL
9519 if test -n "$TAIL"; then
9520   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9521 $as_echo "$TAIL" >&6; }
9522 else
9523   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9524 $as_echo "no" >&6; }
9525 fi
9526 
9527 
9528   test -n "$TAIL" && break
9529 done
9530 
9531     else
9532       # If it succeeded, then it was overridden by the user. We will use it
9533       # for the tool.
9534 
9535       # First remove it from the list of overridden variables, so we can test
9536       # for unknown variables in the end.
9537       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9538 
9539       # Check if the provided tool contains a complete path.
9540       tool_specified="$TAIL"
9541       tool_basename="${tool_specified##*/}"
9542       if test "x$tool_basename" = "x$tool_specified"; then
9543         # A command without a complete path is provided, search $PATH.
9544         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
9545 $as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
9546         # Extract the first word of "$tool_basename", so it can be a program name with args.
9547 set dummy $tool_basename; ac_word=$2
9548 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9549 $as_echo_n "checking for $ac_word... " >&6; }
9550 if ${ac_cv_path_TAIL+:} false; then :
9551   $as_echo_n "(cached) " >&6
9552 else
9553   case $TAIL in
9554   [\\/]* | ?:[\\/]*)
9555   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9556   ;;
9557   *)
9558   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9559 for as_dir in $PATH
9560 do
9561   IFS=$as_save_IFS
9562   test -z "$as_dir" && as_dir=.
9563     for ac_exec_ext in '' $ac_executable_extensions; do
9564   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9565     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9566     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9567     break 2
9568   fi
9569 done
9570   done
9571 IFS=$as_save_IFS
9572 
9573   ;;
9574 esac
9575 fi
9576 TAIL=$ac_cv_path_TAIL
9577 if test -n "$TAIL"; then
9578   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9579 $as_echo "$TAIL" >&6; }
9580 else
9581   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9582 $as_echo "no" >&6; }
9583 fi
9584 
9585 
9586         if test "x$TAIL" = x; then
9587           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9588         fi
9589       else
9590         # Otherwise we believe it is a complete path. Use it as it is.
9591         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
9592 $as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
9593         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
9594 $as_echo_n "checking for TAIL... " >&6; }
9595         if test ! -x "$tool_specified"; then
9596           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9597 $as_echo "not found" >&6; }
9598           as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
9599         fi
9600         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9601 $as_echo "$tool_specified" >&6; }
9602       fi
9603     fi
9604   fi
9605 
9606 
9607 
9608   if test "x$TAIL" = x; then
9609     as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
9610   fi
9611 
9612 
9613 
9614 
9615 
9616   # Publish this variable in the help.
9617 
9618 
9619   if test "x$TAR" = x; then
9620     # The variable is not set by user, try to locate tool using the code snippet
9621     for ac_prog in tar
9622 do
9623   # Extract the first word of "$ac_prog", so it can be a program name with args.
9624 set dummy $ac_prog; ac_word=$2
9625 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9626 $as_echo_n "checking for $ac_word... " >&6; }
9627 if ${ac_cv_path_TAR+:} false; then :
9628   $as_echo_n "(cached) " >&6
9629 else
9630   case $TAR in
9631   [\\/]* | ?:[\\/]*)
9632   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9633   ;;
9634   *)
9635   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9636 for as_dir in $PATH
9637 do
9638   IFS=$as_save_IFS
9639   test -z "$as_dir" && as_dir=.
9640     for ac_exec_ext in '' $ac_executable_extensions; do
9641   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9642     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9643     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9644     break 2
9645   fi
9646 done
9647   done
9648 IFS=$as_save_IFS
9649 
9650   ;;
9651 esac
9652 fi
9653 TAR=$ac_cv_path_TAR
9654 if test -n "$TAR"; then
9655   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9656 $as_echo "$TAR" >&6; }
9657 else
9658   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9659 $as_echo "no" >&6; }
9660 fi
9661 
9662 
9663   test -n "$TAR" && break
9664 done
9665 
9666   else
9667     # The variable is set, but is it from the command line or the environment?
9668 
9669     # Try to remove the string !TAR! from our list.
9670     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
9671     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9672       # If it failed, the variable was not from the command line. Ignore it,
9673       # but warn the user (except for BASH, which is always set by the calling BASH).
9674       if test "xTAR" != xBASH; then
9675         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
9676 $as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
9677       fi
9678       # Try to locate tool using the code snippet
9679       for ac_prog in tar
9680 do
9681   # Extract the first word of "$ac_prog", so it can be a program name with args.
9682 set dummy $ac_prog; ac_word=$2
9683 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9684 $as_echo_n "checking for $ac_word... " >&6; }
9685 if ${ac_cv_path_TAR+:} false; then :
9686   $as_echo_n "(cached) " >&6
9687 else
9688   case $TAR in
9689   [\\/]* | ?:[\\/]*)
9690   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9691   ;;
9692   *)
9693   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9694 for as_dir in $PATH
9695 do
9696   IFS=$as_save_IFS
9697   test -z "$as_dir" && as_dir=.
9698     for ac_exec_ext in '' $ac_executable_extensions; do
9699   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9700     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9701     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9702     break 2
9703   fi
9704 done
9705   done
9706 IFS=$as_save_IFS
9707 
9708   ;;
9709 esac
9710 fi
9711 TAR=$ac_cv_path_TAR
9712 if test -n "$TAR"; then
9713   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9714 $as_echo "$TAR" >&6; }
9715 else
9716   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9717 $as_echo "no" >&6; }
9718 fi
9719 
9720 
9721   test -n "$TAR" && break
9722 done
9723 
9724     else
9725       # If it succeeded, then it was overridden by the user. We will use it
9726       # for the tool.
9727 
9728       # First remove it from the list of overridden variables, so we can test
9729       # for unknown variables in the end.
9730       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9731 
9732       # Check if the provided tool contains a complete path.
9733       tool_specified="$TAR"
9734       tool_basename="${tool_specified##*/}"
9735       if test "x$tool_basename" = "x$tool_specified"; then
9736         # A command without a complete path is provided, search $PATH.
9737         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
9738 $as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
9739         # Extract the first word of "$tool_basename", so it can be a program name with args.
9740 set dummy $tool_basename; ac_word=$2
9741 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9742 $as_echo_n "checking for $ac_word... " >&6; }
9743 if ${ac_cv_path_TAR+:} false; then :
9744   $as_echo_n "(cached) " >&6
9745 else
9746   case $TAR in
9747   [\\/]* | ?:[\\/]*)
9748   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9749   ;;
9750   *)
9751   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9752 for as_dir in $PATH
9753 do
9754   IFS=$as_save_IFS
9755   test -z "$as_dir" && as_dir=.
9756     for ac_exec_ext in '' $ac_executable_extensions; do
9757   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9758     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9759     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9760     break 2
9761   fi
9762 done
9763   done
9764 IFS=$as_save_IFS
9765 
9766   ;;
9767 esac
9768 fi
9769 TAR=$ac_cv_path_TAR
9770 if test -n "$TAR"; then
9771   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9772 $as_echo "$TAR" >&6; }
9773 else
9774   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9775 $as_echo "no" >&6; }
9776 fi
9777 
9778 
9779         if test "x$TAR" = x; then
9780           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9781         fi
9782       else
9783         # Otherwise we believe it is a complete path. Use it as it is.
9784         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
9785 $as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
9786         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
9787 $as_echo_n "checking for TAR... " >&6; }
9788         if test ! -x "$tool_specified"; then
9789           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9790 $as_echo "not found" >&6; }
9791           as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
9792         fi
9793         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9794 $as_echo "$tool_specified" >&6; }
9795       fi
9796     fi
9797   fi
9798 
9799 
9800 
9801   if test "x$TAR" = x; then
9802     as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
9803   fi
9804 
9805 
9806 
9807 
9808 
9809   # Publish this variable in the help.
9810 
9811 
9812   if test "x$TEE" = x; then
9813     # The variable is not set by user, try to locate tool using the code snippet
9814     for ac_prog in tee
9815 do
9816   # Extract the first word of "$ac_prog", so it can be a program name with args.
9817 set dummy $ac_prog; ac_word=$2
9818 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9819 $as_echo_n "checking for $ac_word... " >&6; }
9820 if ${ac_cv_path_TEE+:} false; then :
9821   $as_echo_n "(cached) " >&6
9822 else
9823   case $TEE in
9824   [\\/]* | ?:[\\/]*)
9825   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9826   ;;
9827   *)
9828   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9829 for as_dir in $PATH
9830 do
9831   IFS=$as_save_IFS
9832   test -z "$as_dir" && as_dir=.
9833     for ac_exec_ext in '' $ac_executable_extensions; do
9834   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9835     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9836     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9837     break 2
9838   fi
9839 done
9840   done
9841 IFS=$as_save_IFS
9842 
9843   ;;
9844 esac
9845 fi
9846 TEE=$ac_cv_path_TEE
9847 if test -n "$TEE"; then
9848   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9849 $as_echo "$TEE" >&6; }
9850 else
9851   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9852 $as_echo "no" >&6; }
9853 fi
9854 
9855 
9856   test -n "$TEE" && break
9857 done
9858 
9859   else
9860     # The variable is set, but is it from the command line or the environment?
9861 
9862     # Try to remove the string !TEE! from our list.
9863     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
9864     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9865       # If it failed, the variable was not from the command line. Ignore it,
9866       # but warn the user (except for BASH, which is always set by the calling BASH).
9867       if test "xTEE" != xBASH; then
9868         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
9869 $as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
9870       fi
9871       # Try to locate tool using the code snippet
9872       for ac_prog in tee
9873 do
9874   # Extract the first word of "$ac_prog", so it can be a program name with args.
9875 set dummy $ac_prog; ac_word=$2
9876 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9877 $as_echo_n "checking for $ac_word... " >&6; }
9878 if ${ac_cv_path_TEE+:} false; then :
9879   $as_echo_n "(cached) " >&6
9880 else
9881   case $TEE in
9882   [\\/]* | ?:[\\/]*)
9883   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9884   ;;
9885   *)
9886   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9887 for as_dir in $PATH
9888 do
9889   IFS=$as_save_IFS
9890   test -z "$as_dir" && as_dir=.
9891     for ac_exec_ext in '' $ac_executable_extensions; do
9892   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9893     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9894     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9895     break 2
9896   fi
9897 done
9898   done
9899 IFS=$as_save_IFS
9900 
9901   ;;
9902 esac
9903 fi
9904 TEE=$ac_cv_path_TEE
9905 if test -n "$TEE"; then
9906   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9907 $as_echo "$TEE" >&6; }
9908 else
9909   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9910 $as_echo "no" >&6; }
9911 fi
9912 
9913 
9914   test -n "$TEE" && break
9915 done
9916 
9917     else
9918       # If it succeeded, then it was overridden by the user. We will use it
9919       # for the tool.
9920 
9921       # First remove it from the list of overridden variables, so we can test
9922       # for unknown variables in the end.
9923       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9924 
9925       # Check if the provided tool contains a complete path.
9926       tool_specified="$TEE"
9927       tool_basename="${tool_specified##*/}"
9928       if test "x$tool_basename" = "x$tool_specified"; then
9929         # A command without a complete path is provided, search $PATH.
9930         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
9931 $as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
9932         # Extract the first word of "$tool_basename", so it can be a program name with args.
9933 set dummy $tool_basename; ac_word=$2
9934 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9935 $as_echo_n "checking for $ac_word... " >&6; }
9936 if ${ac_cv_path_TEE+:} false; then :
9937   $as_echo_n "(cached) " >&6
9938 else
9939   case $TEE in
9940   [\\/]* | ?:[\\/]*)
9941   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9942   ;;
9943   *)
9944   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9945 for as_dir in $PATH
9946 do
9947   IFS=$as_save_IFS
9948   test -z "$as_dir" && as_dir=.
9949     for ac_exec_ext in '' $ac_executable_extensions; do
9950   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9951     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9952     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9953     break 2
9954   fi
9955 done
9956   done
9957 IFS=$as_save_IFS
9958 
9959   ;;
9960 esac
9961 fi
9962 TEE=$ac_cv_path_TEE
9963 if test -n "$TEE"; then
9964   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9965 $as_echo "$TEE" >&6; }
9966 else
9967   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9968 $as_echo "no" >&6; }
9969 fi
9970 
9971 
9972         if test "x$TEE" = x; then
9973           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9974         fi
9975       else
9976         # Otherwise we believe it is a complete path. Use it as it is.
9977         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
9978 $as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
9979         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
9980 $as_echo_n "checking for TEE... " >&6; }
9981         if test ! -x "$tool_specified"; then
9982           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9983 $as_echo "not found" >&6; }
9984           as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
9985         fi
9986         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9987 $as_echo "$tool_specified" >&6; }
9988       fi
9989     fi
9990   fi
9991 
9992 
9993 
9994   if test "x$TEE" = x; then
9995     as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
9996   fi
9997 
9998 
9999 
10000 
10001 
10002   # Publish this variable in the help.
10003 
10004 
10005   if test "x$TOUCH" = x; then
10006     # The variable is not set by user, try to locate tool using the code snippet
10007     for ac_prog in touch
10008 do
10009   # Extract the first word of "$ac_prog", so it can be a program name with args.
10010 set dummy $ac_prog; ac_word=$2
10011 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10012 $as_echo_n "checking for $ac_word... " >&6; }
10013 if ${ac_cv_path_TOUCH+:} false; then :
10014   $as_echo_n "(cached) " >&6
10015 else
10016   case $TOUCH in
10017   [\\/]* | ?:[\\/]*)
10018   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10019   ;;
10020   *)
10021   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10022 for as_dir in $PATH
10023 do
10024   IFS=$as_save_IFS
10025   test -z "$as_dir" && as_dir=.
10026     for ac_exec_ext in '' $ac_executable_extensions; do
10027   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10028     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10029     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10030     break 2
10031   fi
10032 done
10033   done
10034 IFS=$as_save_IFS
10035 
10036   ;;
10037 esac
10038 fi
10039 TOUCH=$ac_cv_path_TOUCH
10040 if test -n "$TOUCH"; then
10041   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10042 $as_echo "$TOUCH" >&6; }
10043 else
10044   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10045 $as_echo "no" >&6; }
10046 fi
10047 
10048 
10049   test -n "$TOUCH" && break
10050 done
10051 
10052   else
10053     # The variable is set, but is it from the command line or the environment?
10054 
10055     # Try to remove the string !TOUCH! from our list.
10056     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
10057     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10058       # If it failed, the variable was not from the command line. Ignore it,
10059       # but warn the user (except for BASH, which is always set by the calling BASH).
10060       if test "xTOUCH" != xBASH; then
10061         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
10062 $as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
10063       fi
10064       # Try to locate tool using the code snippet
10065       for ac_prog in touch
10066 do
10067   # Extract the first word of "$ac_prog", so it can be a program name with args.
10068 set dummy $ac_prog; ac_word=$2
10069 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10070 $as_echo_n "checking for $ac_word... " >&6; }
10071 if ${ac_cv_path_TOUCH+:} false; then :
10072   $as_echo_n "(cached) " >&6
10073 else
10074   case $TOUCH in
10075   [\\/]* | ?:[\\/]*)
10076   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10077   ;;
10078   *)
10079   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10080 for as_dir in $PATH
10081 do
10082   IFS=$as_save_IFS
10083   test -z "$as_dir" && as_dir=.
10084     for ac_exec_ext in '' $ac_executable_extensions; do
10085   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10086     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10087     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10088     break 2
10089   fi
10090 done
10091   done
10092 IFS=$as_save_IFS
10093 
10094   ;;
10095 esac
10096 fi
10097 TOUCH=$ac_cv_path_TOUCH
10098 if test -n "$TOUCH"; then
10099   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10100 $as_echo "$TOUCH" >&6; }
10101 else
10102   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10103 $as_echo "no" >&6; }
10104 fi
10105 
10106 
10107   test -n "$TOUCH" && break
10108 done
10109 
10110     else
10111       # If it succeeded, then it was overridden by the user. We will use it
10112       # for the tool.
10113 
10114       # First remove it from the list of overridden variables, so we can test
10115       # for unknown variables in the end.
10116       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10117 
10118       # Check if the provided tool contains a complete path.
10119       tool_specified="$TOUCH"
10120       tool_basename="${tool_specified##*/}"
10121       if test "x$tool_basename" = "x$tool_specified"; then
10122         # A command without a complete path is provided, search $PATH.
10123         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
10124 $as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
10125         # Extract the first word of "$tool_basename", so it can be a program name with args.
10126 set dummy $tool_basename; ac_word=$2
10127 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10128 $as_echo_n "checking for $ac_word... " >&6; }
10129 if ${ac_cv_path_TOUCH+:} false; then :
10130   $as_echo_n "(cached) " >&6
10131 else
10132   case $TOUCH in
10133   [\\/]* | ?:[\\/]*)
10134   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10135   ;;
10136   *)
10137   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10138 for as_dir in $PATH
10139 do
10140   IFS=$as_save_IFS
10141   test -z "$as_dir" && as_dir=.
10142     for ac_exec_ext in '' $ac_executable_extensions; do
10143   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10144     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10145     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10146     break 2
10147   fi
10148 done
10149   done
10150 IFS=$as_save_IFS
10151 
10152   ;;
10153 esac
10154 fi
10155 TOUCH=$ac_cv_path_TOUCH
10156 if test -n "$TOUCH"; then
10157   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10158 $as_echo "$TOUCH" >&6; }
10159 else
10160   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10161 $as_echo "no" >&6; }
10162 fi
10163 
10164 
10165         if test "x$TOUCH" = x; then
10166           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10167         fi
10168       else
10169         # Otherwise we believe it is a complete path. Use it as it is.
10170         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
10171 $as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
10172         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
10173 $as_echo_n "checking for TOUCH... " >&6; }
10174         if test ! -x "$tool_specified"; then
10175           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10176 $as_echo "not found" >&6; }
10177           as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
10178         fi
10179         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10180 $as_echo "$tool_specified" >&6; }
10181       fi
10182     fi
10183   fi
10184 
10185 
10186 
10187   if test "x$TOUCH" = x; then
10188     as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
10189   fi
10190 
10191 
10192 
10193 
10194 
10195   # Publish this variable in the help.
10196 
10197 
10198   if test "x$TR" = x; then
10199     # The variable is not set by user, try to locate tool using the code snippet
10200     for ac_prog in tr
10201 do
10202   # Extract the first word of "$ac_prog", so it can be a program name with args.
10203 set dummy $ac_prog; ac_word=$2
10204 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10205 $as_echo_n "checking for $ac_word... " >&6; }
10206 if ${ac_cv_path_TR+:} false; then :
10207   $as_echo_n "(cached) " >&6
10208 else
10209   case $TR in
10210   [\\/]* | ?:[\\/]*)
10211   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10212   ;;
10213   *)
10214   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10215 for as_dir in $PATH
10216 do
10217   IFS=$as_save_IFS
10218   test -z "$as_dir" && as_dir=.
10219     for ac_exec_ext in '' $ac_executable_extensions; do
10220   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10221     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10222     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10223     break 2
10224   fi
10225 done
10226   done
10227 IFS=$as_save_IFS
10228 
10229   ;;
10230 esac
10231 fi
10232 TR=$ac_cv_path_TR
10233 if test -n "$TR"; then
10234   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10235 $as_echo "$TR" >&6; }
10236 else
10237   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10238 $as_echo "no" >&6; }
10239 fi
10240 
10241 
10242   test -n "$TR" && break
10243 done
10244 
10245   else
10246     # The variable is set, but is it from the command line or the environment?
10247 
10248     # Try to remove the string !TR! from our list.
10249     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
10250     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10251       # If it failed, the variable was not from the command line. Ignore it,
10252       # but warn the user (except for BASH, which is always set by the calling BASH).
10253       if test "xTR" != xBASH; then
10254         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
10255 $as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
10256       fi
10257       # Try to locate tool using the code snippet
10258       for ac_prog in tr
10259 do
10260   # Extract the first word of "$ac_prog", so it can be a program name with args.
10261 set dummy $ac_prog; ac_word=$2
10262 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10263 $as_echo_n "checking for $ac_word... " >&6; }
10264 if ${ac_cv_path_TR+:} false; then :
10265   $as_echo_n "(cached) " >&6
10266 else
10267   case $TR in
10268   [\\/]* | ?:[\\/]*)
10269   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10270   ;;
10271   *)
10272   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10273 for as_dir in $PATH
10274 do
10275   IFS=$as_save_IFS
10276   test -z "$as_dir" && as_dir=.
10277     for ac_exec_ext in '' $ac_executable_extensions; do
10278   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10279     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10280     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10281     break 2
10282   fi
10283 done
10284   done
10285 IFS=$as_save_IFS
10286 
10287   ;;
10288 esac
10289 fi
10290 TR=$ac_cv_path_TR
10291 if test -n "$TR"; then
10292   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10293 $as_echo "$TR" >&6; }
10294 else
10295   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10296 $as_echo "no" >&6; }
10297 fi
10298 
10299 
10300   test -n "$TR" && break
10301 done
10302 
10303     else
10304       # If it succeeded, then it was overridden by the user. We will use it
10305       # for the tool.
10306 
10307       # First remove it from the list of overridden variables, so we can test
10308       # for unknown variables in the end.
10309       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10310 
10311       # Check if the provided tool contains a complete path.
10312       tool_specified="$TR"
10313       tool_basename="${tool_specified##*/}"
10314       if test "x$tool_basename" = "x$tool_specified"; then
10315         # A command without a complete path is provided, search $PATH.
10316         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
10317 $as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
10318         # Extract the first word of "$tool_basename", so it can be a program name with args.
10319 set dummy $tool_basename; ac_word=$2
10320 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10321 $as_echo_n "checking for $ac_word... " >&6; }
10322 if ${ac_cv_path_TR+:} false; then :
10323   $as_echo_n "(cached) " >&6
10324 else
10325   case $TR in
10326   [\\/]* | ?:[\\/]*)
10327   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10328   ;;
10329   *)
10330   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10331 for as_dir in $PATH
10332 do
10333   IFS=$as_save_IFS
10334   test -z "$as_dir" && as_dir=.
10335     for ac_exec_ext in '' $ac_executable_extensions; do
10336   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10337     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10338     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10339     break 2
10340   fi
10341 done
10342   done
10343 IFS=$as_save_IFS
10344 
10345   ;;
10346 esac
10347 fi
10348 TR=$ac_cv_path_TR
10349 if test -n "$TR"; then
10350   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10351 $as_echo "$TR" >&6; }
10352 else
10353   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10354 $as_echo "no" >&6; }
10355 fi
10356 
10357 
10358         if test "x$TR" = x; then
10359           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10360         fi
10361       else
10362         # Otherwise we believe it is a complete path. Use it as it is.
10363         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
10364 $as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
10365         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
10366 $as_echo_n "checking for TR... " >&6; }
10367         if test ! -x "$tool_specified"; then
10368           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10369 $as_echo "not found" >&6; }
10370           as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
10371         fi
10372         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10373 $as_echo "$tool_specified" >&6; }
10374       fi
10375     fi
10376   fi
10377 
10378 
10379 
10380   if test "x$TR" = x; then
10381     as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
10382   fi
10383 
10384 
10385 
10386 
10387 
10388   # Publish this variable in the help.
10389 
10390 
10391   if test "x$UNAME" = x; then
10392     # The variable is not set by user, try to locate tool using the code snippet
10393     for ac_prog in uname
10394 do
10395   # Extract the first word of "$ac_prog", so it can be a program name with args.
10396 set dummy $ac_prog; ac_word=$2
10397 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10398 $as_echo_n "checking for $ac_word... " >&6; }
10399 if ${ac_cv_path_UNAME+:} false; then :
10400   $as_echo_n "(cached) " >&6
10401 else
10402   case $UNAME in
10403   [\\/]* | ?:[\\/]*)
10404   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10405   ;;
10406   *)
10407   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10408 for as_dir in $PATH
10409 do
10410   IFS=$as_save_IFS
10411   test -z "$as_dir" && as_dir=.
10412     for ac_exec_ext in '' $ac_executable_extensions; do
10413   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10414     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10415     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10416     break 2
10417   fi
10418 done
10419   done
10420 IFS=$as_save_IFS
10421 
10422   ;;
10423 esac
10424 fi
10425 UNAME=$ac_cv_path_UNAME
10426 if test -n "$UNAME"; then
10427   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10428 $as_echo "$UNAME" >&6; }
10429 else
10430   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10431 $as_echo "no" >&6; }
10432 fi
10433 
10434 
10435   test -n "$UNAME" && break
10436 done
10437 
10438   else
10439     # The variable is set, but is it from the command line or the environment?
10440 
10441     # Try to remove the string !UNAME! from our list.
10442     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
10443     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10444       # If it failed, the variable was not from the command line. Ignore it,
10445       # but warn the user (except for BASH, which is always set by the calling BASH).
10446       if test "xUNAME" != xBASH; then
10447         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
10448 $as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
10449       fi
10450       # Try to locate tool using the code snippet
10451       for ac_prog in uname
10452 do
10453   # Extract the first word of "$ac_prog", so it can be a program name with args.
10454 set dummy $ac_prog; ac_word=$2
10455 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10456 $as_echo_n "checking for $ac_word... " >&6; }
10457 if ${ac_cv_path_UNAME+:} false; then :
10458   $as_echo_n "(cached) " >&6
10459 else
10460   case $UNAME in
10461   [\\/]* | ?:[\\/]*)
10462   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10463   ;;
10464   *)
10465   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10466 for as_dir in $PATH
10467 do
10468   IFS=$as_save_IFS
10469   test -z "$as_dir" && as_dir=.
10470     for ac_exec_ext in '' $ac_executable_extensions; do
10471   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10472     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10473     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10474     break 2
10475   fi
10476 done
10477   done
10478 IFS=$as_save_IFS
10479 
10480   ;;
10481 esac
10482 fi
10483 UNAME=$ac_cv_path_UNAME
10484 if test -n "$UNAME"; then
10485   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10486 $as_echo "$UNAME" >&6; }
10487 else
10488   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10489 $as_echo "no" >&6; }
10490 fi
10491 
10492 
10493   test -n "$UNAME" && break
10494 done
10495 
10496     else
10497       # If it succeeded, then it was overridden by the user. We will use it
10498       # for the tool.
10499 
10500       # First remove it from the list of overridden variables, so we can test
10501       # for unknown variables in the end.
10502       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10503 
10504       # Check if the provided tool contains a complete path.
10505       tool_specified="$UNAME"
10506       tool_basename="${tool_specified##*/}"
10507       if test "x$tool_basename" = "x$tool_specified"; then
10508         # A command without a complete path is provided, search $PATH.
10509         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
10510 $as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
10511         # Extract the first word of "$tool_basename", so it can be a program name with args.
10512 set dummy $tool_basename; ac_word=$2
10513 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10514 $as_echo_n "checking for $ac_word... " >&6; }
10515 if ${ac_cv_path_UNAME+:} false; then :
10516   $as_echo_n "(cached) " >&6
10517 else
10518   case $UNAME in
10519   [\\/]* | ?:[\\/]*)
10520   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10521   ;;
10522   *)
10523   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10524 for as_dir in $PATH
10525 do
10526   IFS=$as_save_IFS
10527   test -z "$as_dir" && as_dir=.
10528     for ac_exec_ext in '' $ac_executable_extensions; do
10529   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10530     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10531     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10532     break 2
10533   fi
10534 done
10535   done
10536 IFS=$as_save_IFS
10537 
10538   ;;
10539 esac
10540 fi
10541 UNAME=$ac_cv_path_UNAME
10542 if test -n "$UNAME"; then
10543   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10544 $as_echo "$UNAME" >&6; }
10545 else
10546   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10547 $as_echo "no" >&6; }
10548 fi
10549 
10550 
10551         if test "x$UNAME" = x; then
10552           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10553         fi
10554       else
10555         # Otherwise we believe it is a complete path. Use it as it is.
10556         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
10557 $as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
10558         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
10559 $as_echo_n "checking for UNAME... " >&6; }
10560         if test ! -x "$tool_specified"; then
10561           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10562 $as_echo "not found" >&6; }
10563           as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
10564         fi
10565         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10566 $as_echo "$tool_specified" >&6; }
10567       fi
10568     fi
10569   fi
10570 
10571 
10572 
10573   if test "x$UNAME" = x; then
10574     as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
10575   fi
10576 
10577 
10578 
10579 
10580 
10581   # Publish this variable in the help.
10582 
10583 
10584   if test "x$UNIQ" = x; then
10585     # The variable is not set by user, try to locate tool using the code snippet
10586     for ac_prog in uniq
10587 do
10588   # Extract the first word of "$ac_prog", so it can be a program name with args.
10589 set dummy $ac_prog; ac_word=$2
10590 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10591 $as_echo_n "checking for $ac_word... " >&6; }
10592 if ${ac_cv_path_UNIQ+:} false; then :
10593   $as_echo_n "(cached) " >&6
10594 else
10595   case $UNIQ in
10596   [\\/]* | ?:[\\/]*)
10597   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10598   ;;
10599   *)
10600   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10601 for as_dir in $PATH
10602 do
10603   IFS=$as_save_IFS
10604   test -z "$as_dir" && as_dir=.
10605     for ac_exec_ext in '' $ac_executable_extensions; do
10606   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10607     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10608     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10609     break 2
10610   fi
10611 done
10612   done
10613 IFS=$as_save_IFS
10614 
10615   ;;
10616 esac
10617 fi
10618 UNIQ=$ac_cv_path_UNIQ
10619 if test -n "$UNIQ"; then
10620   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10621 $as_echo "$UNIQ" >&6; }
10622 else
10623   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10624 $as_echo "no" >&6; }
10625 fi
10626 
10627 
10628   test -n "$UNIQ" && break
10629 done
10630 
10631   else
10632     # The variable is set, but is it from the command line or the environment?
10633 
10634     # Try to remove the string !UNIQ! from our list.
10635     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
10636     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10637       # If it failed, the variable was not from the command line. Ignore it,
10638       # but warn the user (except for BASH, which is always set by the calling BASH).
10639       if test "xUNIQ" != xBASH; then
10640         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
10641 $as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
10642       fi
10643       # Try to locate tool using the code snippet
10644       for ac_prog in uniq
10645 do
10646   # Extract the first word of "$ac_prog", so it can be a program name with args.
10647 set dummy $ac_prog; ac_word=$2
10648 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10649 $as_echo_n "checking for $ac_word... " >&6; }
10650 if ${ac_cv_path_UNIQ+:} false; then :
10651   $as_echo_n "(cached) " >&6
10652 else
10653   case $UNIQ in
10654   [\\/]* | ?:[\\/]*)
10655   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10656   ;;
10657   *)
10658   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10659 for as_dir in $PATH
10660 do
10661   IFS=$as_save_IFS
10662   test -z "$as_dir" && as_dir=.
10663     for ac_exec_ext in '' $ac_executable_extensions; do
10664   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10665     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10666     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10667     break 2
10668   fi
10669 done
10670   done
10671 IFS=$as_save_IFS
10672 
10673   ;;
10674 esac
10675 fi
10676 UNIQ=$ac_cv_path_UNIQ
10677 if test -n "$UNIQ"; then
10678   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10679 $as_echo "$UNIQ" >&6; }
10680 else
10681   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10682 $as_echo "no" >&6; }
10683 fi
10684 
10685 
10686   test -n "$UNIQ" && break
10687 done
10688 
10689     else
10690       # If it succeeded, then it was overridden by the user. We will use it
10691       # for the tool.
10692 
10693       # First remove it from the list of overridden variables, so we can test
10694       # for unknown variables in the end.
10695       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10696 
10697       # Check if the provided tool contains a complete path.
10698       tool_specified="$UNIQ"
10699       tool_basename="${tool_specified##*/}"
10700       if test "x$tool_basename" = "x$tool_specified"; then
10701         # A command without a complete path is provided, search $PATH.
10702         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
10703 $as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
10704         # Extract the first word of "$tool_basename", so it can be a program name with args.
10705 set dummy $tool_basename; ac_word=$2
10706 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10707 $as_echo_n "checking for $ac_word... " >&6; }
10708 if ${ac_cv_path_UNIQ+:} false; then :
10709   $as_echo_n "(cached) " >&6
10710 else
10711   case $UNIQ in
10712   [\\/]* | ?:[\\/]*)
10713   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10714   ;;
10715   *)
10716   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10717 for as_dir in $PATH
10718 do
10719   IFS=$as_save_IFS
10720   test -z "$as_dir" && as_dir=.
10721     for ac_exec_ext in '' $ac_executable_extensions; do
10722   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10723     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10724     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10725     break 2
10726   fi
10727 done
10728   done
10729 IFS=$as_save_IFS
10730 
10731   ;;
10732 esac
10733 fi
10734 UNIQ=$ac_cv_path_UNIQ
10735 if test -n "$UNIQ"; then
10736   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10737 $as_echo "$UNIQ" >&6; }
10738 else
10739   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10740 $as_echo "no" >&6; }
10741 fi
10742 
10743 
10744         if test "x$UNIQ" = x; then
10745           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10746         fi
10747       else
10748         # Otherwise we believe it is a complete path. Use it as it is.
10749         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
10750 $as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
10751         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
10752 $as_echo_n "checking for UNIQ... " >&6; }
10753         if test ! -x "$tool_specified"; then
10754           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10755 $as_echo "not found" >&6; }
10756           as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
10757         fi
10758         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10759 $as_echo "$tool_specified" >&6; }
10760       fi
10761     fi
10762   fi
10763 
10764 
10765 
10766   if test "x$UNIQ" = x; then
10767     as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
10768   fi
10769 
10770 
10771 
10772 
10773 
10774   # Publish this variable in the help.
10775 
10776 
10777   if test "x$WC" = x; then
10778     # The variable is not set by user, try to locate tool using the code snippet
10779     for ac_prog in wc
10780 do
10781   # Extract the first word of "$ac_prog", so it can be a program name with args.
10782 set dummy $ac_prog; ac_word=$2
10783 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10784 $as_echo_n "checking for $ac_word... " >&6; }
10785 if ${ac_cv_path_WC+:} false; then :
10786   $as_echo_n "(cached) " >&6
10787 else
10788   case $WC in
10789   [\\/]* | ?:[\\/]*)
10790   ac_cv_path_WC="$WC" # Let the user override the test with a path.
10791   ;;
10792   *)
10793   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10794 for as_dir in $PATH
10795 do
10796   IFS=$as_save_IFS
10797   test -z "$as_dir" && as_dir=.
10798     for ac_exec_ext in '' $ac_executable_extensions; do
10799   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10800     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10801     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10802     break 2
10803   fi
10804 done
10805   done
10806 IFS=$as_save_IFS
10807 
10808   ;;
10809 esac
10810 fi
10811 WC=$ac_cv_path_WC
10812 if test -n "$WC"; then
10813   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10814 $as_echo "$WC" >&6; }
10815 else
10816   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10817 $as_echo "no" >&6; }
10818 fi
10819 
10820 
10821   test -n "$WC" && break
10822 done
10823 
10824   else
10825     # The variable is set, but is it from the command line or the environment?
10826 
10827     # Try to remove the string !WC! from our list.
10828     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
10829     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10830       # If it failed, the variable was not from the command line. Ignore it,
10831       # but warn the user (except for BASH, which is always set by the calling BASH).
10832       if test "xWC" != xBASH; then
10833         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
10834 $as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
10835       fi
10836       # Try to locate tool using the code snippet
10837       for ac_prog in wc
10838 do
10839   # Extract the first word of "$ac_prog", so it can be a program name with args.
10840 set dummy $ac_prog; ac_word=$2
10841 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10842 $as_echo_n "checking for $ac_word... " >&6; }
10843 if ${ac_cv_path_WC+:} false; then :
10844   $as_echo_n "(cached) " >&6
10845 else
10846   case $WC in
10847   [\\/]* | ?:[\\/]*)
10848   ac_cv_path_WC="$WC" # Let the user override the test with a path.
10849   ;;
10850   *)
10851   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10852 for as_dir in $PATH
10853 do
10854   IFS=$as_save_IFS
10855   test -z "$as_dir" && as_dir=.
10856     for ac_exec_ext in '' $ac_executable_extensions; do
10857   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10858     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10859     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10860     break 2
10861   fi
10862 done
10863   done
10864 IFS=$as_save_IFS
10865 
10866   ;;
10867 esac
10868 fi
10869 WC=$ac_cv_path_WC
10870 if test -n "$WC"; then
10871   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10872 $as_echo "$WC" >&6; }
10873 else
10874   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10875 $as_echo "no" >&6; }
10876 fi
10877 
10878 
10879   test -n "$WC" && break
10880 done
10881 
10882     else
10883       # If it succeeded, then it was overridden by the user. We will use it
10884       # for the tool.
10885 
10886       # First remove it from the list of overridden variables, so we can test
10887       # for unknown variables in the end.
10888       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10889 
10890       # Check if the provided tool contains a complete path.
10891       tool_specified="$WC"
10892       tool_basename="${tool_specified##*/}"
10893       if test "x$tool_basename" = "x$tool_specified"; then
10894         # A command without a complete path is provided, search $PATH.
10895         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
10896 $as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
10897         # Extract the first word of "$tool_basename", so it can be a program name with args.
10898 set dummy $tool_basename; ac_word=$2
10899 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10900 $as_echo_n "checking for $ac_word... " >&6; }
10901 if ${ac_cv_path_WC+:} false; then :
10902   $as_echo_n "(cached) " >&6
10903 else
10904   case $WC in
10905   [\\/]* | ?:[\\/]*)
10906   ac_cv_path_WC="$WC" # Let the user override the test with a path.
10907   ;;
10908   *)
10909   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10910 for as_dir in $PATH
10911 do
10912   IFS=$as_save_IFS
10913   test -z "$as_dir" && as_dir=.
10914     for ac_exec_ext in '' $ac_executable_extensions; do
10915   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10916     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10917     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10918     break 2
10919   fi
10920 done
10921   done
10922 IFS=$as_save_IFS
10923 
10924   ;;
10925 esac
10926 fi
10927 WC=$ac_cv_path_WC
10928 if test -n "$WC"; then
10929   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10930 $as_echo "$WC" >&6; }
10931 else
10932   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10933 $as_echo "no" >&6; }
10934 fi
10935 
10936 
10937         if test "x$WC" = x; then
10938           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10939         fi
10940       else
10941         # Otherwise we believe it is a complete path. Use it as it is.
10942         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
10943 $as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
10944         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
10945 $as_echo_n "checking for WC... " >&6; }
10946         if test ! -x "$tool_specified"; then
10947           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10948 $as_echo "not found" >&6; }
10949           as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
10950         fi
10951         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10952 $as_echo "$tool_specified" >&6; }
10953       fi
10954     fi
10955   fi
10956 
10957 
10958 
10959   if test "x$WC" = x; then
10960     as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
10961   fi
10962 
10963 
10964 
10965 
10966 
10967   # Publish this variable in the help.
10968 
10969 
10970   if test "x$WHICH" = x; then
10971     # The variable is not set by user, try to locate tool using the code snippet
10972     for ac_prog in which
10973 do
10974   # Extract the first word of "$ac_prog", so it can be a program name with args.
10975 set dummy $ac_prog; ac_word=$2
10976 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10977 $as_echo_n "checking for $ac_word... " >&6; }
10978 if ${ac_cv_path_WHICH+:} false; then :
10979   $as_echo_n "(cached) " >&6
10980 else
10981   case $WHICH in
10982   [\\/]* | ?:[\\/]*)
10983   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
10984   ;;
10985   *)
10986   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10987 for as_dir in $PATH
10988 do
10989   IFS=$as_save_IFS
10990   test -z "$as_dir" && as_dir=.
10991     for ac_exec_ext in '' $ac_executable_extensions; do
10992   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10993     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
10994     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10995     break 2
10996   fi
10997 done
10998   done
10999 IFS=$as_save_IFS
11000 
11001   ;;
11002 esac
11003 fi
11004 WHICH=$ac_cv_path_WHICH
11005 if test -n "$WHICH"; then
11006   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11007 $as_echo "$WHICH" >&6; }
11008 else
11009   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11010 $as_echo "no" >&6; }
11011 fi
11012 
11013 
11014   test -n "$WHICH" && break
11015 done
11016 
11017   else
11018     # The variable is set, but is it from the command line or the environment?
11019 
11020     # Try to remove the string !WHICH! from our list.
11021     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
11022     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11023       # If it failed, the variable was not from the command line. Ignore it,
11024       # but warn the user (except for BASH, which is always set by the calling BASH).
11025       if test "xWHICH" != xBASH; then
11026         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
11027 $as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
11028       fi
11029       # Try to locate tool using the code snippet
11030       for ac_prog in which
11031 do
11032   # Extract the first word of "$ac_prog", so it can be a program name with args.
11033 set dummy $ac_prog; ac_word=$2
11034 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11035 $as_echo_n "checking for $ac_word... " >&6; }
11036 if ${ac_cv_path_WHICH+:} false; then :
11037   $as_echo_n "(cached) " >&6
11038 else
11039   case $WHICH in
11040   [\\/]* | ?:[\\/]*)
11041   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11042   ;;
11043   *)
11044   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11045 for as_dir in $PATH
11046 do
11047   IFS=$as_save_IFS
11048   test -z "$as_dir" && as_dir=.
11049     for ac_exec_ext in '' $ac_executable_extensions; do
11050   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11051     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11052     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11053     break 2
11054   fi
11055 done
11056   done
11057 IFS=$as_save_IFS
11058 
11059   ;;
11060 esac
11061 fi
11062 WHICH=$ac_cv_path_WHICH
11063 if test -n "$WHICH"; then
11064   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11065 $as_echo "$WHICH" >&6; }
11066 else
11067   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11068 $as_echo "no" >&6; }
11069 fi
11070 
11071 
11072   test -n "$WHICH" && break
11073 done
11074 
11075     else
11076       # If it succeeded, then it was overridden by the user. We will use it
11077       # for the tool.
11078 
11079       # First remove it from the list of overridden variables, so we can test
11080       # for unknown variables in the end.
11081       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11082 
11083       # Check if the provided tool contains a complete path.
11084       tool_specified="$WHICH"
11085       tool_basename="${tool_specified##*/}"
11086       if test "x$tool_basename" = "x$tool_specified"; then
11087         # A command without a complete path is provided, search $PATH.
11088         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
11089 $as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
11090         # Extract the first word of "$tool_basename", so it can be a program name with args.
11091 set dummy $tool_basename; ac_word=$2
11092 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11093 $as_echo_n "checking for $ac_word... " >&6; }
11094 if ${ac_cv_path_WHICH+:} false; then :
11095   $as_echo_n "(cached) " >&6
11096 else
11097   case $WHICH in
11098   [\\/]* | ?:[\\/]*)
11099   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11100   ;;
11101   *)
11102   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11103 for as_dir in $PATH
11104 do
11105   IFS=$as_save_IFS
11106   test -z "$as_dir" && as_dir=.
11107     for ac_exec_ext in '' $ac_executable_extensions; do
11108   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11109     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11110     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11111     break 2
11112   fi
11113 done
11114   done
11115 IFS=$as_save_IFS
11116 
11117   ;;
11118 esac
11119 fi
11120 WHICH=$ac_cv_path_WHICH
11121 if test -n "$WHICH"; then
11122   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11123 $as_echo "$WHICH" >&6; }
11124 else
11125   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11126 $as_echo "no" >&6; }
11127 fi
11128 
11129 
11130         if test "x$WHICH" = x; then
11131           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11132         fi
11133       else
11134         # Otherwise we believe it is a complete path. Use it as it is.
11135         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
11136 $as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
11137         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
11138 $as_echo_n "checking for WHICH... " >&6; }
11139         if test ! -x "$tool_specified"; then
11140           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11141 $as_echo "not found" >&6; }
11142           as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
11143         fi
11144         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11145 $as_echo "$tool_specified" >&6; }
11146       fi
11147     fi
11148   fi
11149 
11150 
11151 
11152   if test "x$WHICH" = x; then
11153     as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
11154   fi
11155 
11156 
11157 
11158 
11159 
11160   # Publish this variable in the help.
11161 
11162 
11163   if test "x$XARGS" = x; then
11164     # The variable is not set by user, try to locate tool using the code snippet
11165     for ac_prog in xargs
11166 do
11167   # Extract the first word of "$ac_prog", so it can be a program name with args.
11168 set dummy $ac_prog; ac_word=$2
11169 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11170 $as_echo_n "checking for $ac_word... " >&6; }
11171 if ${ac_cv_path_XARGS+:} false; then :
11172   $as_echo_n "(cached) " >&6
11173 else
11174   case $XARGS in
11175   [\\/]* | ?:[\\/]*)
11176   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11177   ;;
11178   *)
11179   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11180 for as_dir in $PATH
11181 do
11182   IFS=$as_save_IFS
11183   test -z "$as_dir" && as_dir=.
11184     for ac_exec_ext in '' $ac_executable_extensions; do
11185   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11186     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11187     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11188     break 2
11189   fi
11190 done
11191   done
11192 IFS=$as_save_IFS
11193 
11194   ;;
11195 esac
11196 fi
11197 XARGS=$ac_cv_path_XARGS
11198 if test -n "$XARGS"; then
11199   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11200 $as_echo "$XARGS" >&6; }
11201 else
11202   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11203 $as_echo "no" >&6; }
11204 fi
11205 
11206 
11207   test -n "$XARGS" && break
11208 done
11209 
11210   else
11211     # The variable is set, but is it from the command line or the environment?
11212 
11213     # Try to remove the string !XARGS! from our list.
11214     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
11215     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11216       # If it failed, the variable was not from the command line. Ignore it,
11217       # but warn the user (except for BASH, which is always set by the calling BASH).
11218       if test "xXARGS" != xBASH; then
11219         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
11220 $as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
11221       fi
11222       # Try to locate tool using the code snippet
11223       for ac_prog in xargs
11224 do
11225   # Extract the first word of "$ac_prog", so it can be a program name with args.
11226 set dummy $ac_prog; ac_word=$2
11227 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11228 $as_echo_n "checking for $ac_word... " >&6; }
11229 if ${ac_cv_path_XARGS+:} false; then :
11230   $as_echo_n "(cached) " >&6
11231 else
11232   case $XARGS in
11233   [\\/]* | ?:[\\/]*)
11234   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11235   ;;
11236   *)
11237   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11238 for as_dir in $PATH
11239 do
11240   IFS=$as_save_IFS
11241   test -z "$as_dir" && as_dir=.
11242     for ac_exec_ext in '' $ac_executable_extensions; do
11243   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11244     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11245     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11246     break 2
11247   fi
11248 done
11249   done
11250 IFS=$as_save_IFS
11251 
11252   ;;
11253 esac
11254 fi
11255 XARGS=$ac_cv_path_XARGS
11256 if test -n "$XARGS"; then
11257   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11258 $as_echo "$XARGS" >&6; }
11259 else
11260   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11261 $as_echo "no" >&6; }
11262 fi
11263 
11264 
11265   test -n "$XARGS" && break
11266 done
11267 
11268     else
11269       # If it succeeded, then it was overridden by the user. We will use it
11270       # for the tool.
11271 
11272       # First remove it from the list of overridden variables, so we can test
11273       # for unknown variables in the end.
11274       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11275 
11276       # Check if the provided tool contains a complete path.
11277       tool_specified="$XARGS"
11278       tool_basename="${tool_specified##*/}"
11279       if test "x$tool_basename" = "x$tool_specified"; then
11280         # A command without a complete path is provided, search $PATH.
11281         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
11282 $as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
11283         # Extract the first word of "$tool_basename", so it can be a program name with args.
11284 set dummy $tool_basename; ac_word=$2
11285 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11286 $as_echo_n "checking for $ac_word... " >&6; }
11287 if ${ac_cv_path_XARGS+:} false; then :
11288   $as_echo_n "(cached) " >&6
11289 else
11290   case $XARGS in
11291   [\\/]* | ?:[\\/]*)
11292   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11293   ;;
11294   *)
11295   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11296 for as_dir in $PATH
11297 do
11298   IFS=$as_save_IFS
11299   test -z "$as_dir" && as_dir=.
11300     for ac_exec_ext in '' $ac_executable_extensions; do
11301   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11302     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11303     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11304     break 2
11305   fi
11306 done
11307   done
11308 IFS=$as_save_IFS
11309 
11310   ;;
11311 esac
11312 fi
11313 XARGS=$ac_cv_path_XARGS
11314 if test -n "$XARGS"; then
11315   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11316 $as_echo "$XARGS" >&6; }
11317 else
11318   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11319 $as_echo "no" >&6; }
11320 fi
11321 
11322 
11323         if test "x$XARGS" = x; then
11324           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11325         fi
11326       else
11327         # Otherwise we believe it is a complete path. Use it as it is.
11328         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
11329 $as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
11330         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
11331 $as_echo_n "checking for XARGS... " >&6; }
11332         if test ! -x "$tool_specified"; then
11333           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11334 $as_echo "not found" >&6; }
11335           as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
11336         fi
11337         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11338 $as_echo "$tool_specified" >&6; }
11339       fi
11340     fi
11341   fi
11342 
11343 
11344 
11345   if test "x$XARGS" = x; then
11346     as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
11347   fi
11348 
11349 
11350 
11351   # Then required tools that require some special treatment.
11352 
11353 
11354   # Publish this variable in the help.
11355 
11356 
11357   if test "x$AWK" = x; then
11358     # The variable is not set by user, try to locate tool using the code snippet
11359     for ac_prog in gawk mawk nawk awk
11360 do
11361   # Extract the first word of "$ac_prog", so it can be a program name with args.
11362 set dummy $ac_prog; ac_word=$2
11363 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11364 $as_echo_n "checking for $ac_word... " >&6; }
11365 if ${ac_cv_prog_AWK+:} false; then :
11366   $as_echo_n "(cached) " >&6
11367 else
11368   if test -n "$AWK"; then
11369   ac_cv_prog_AWK="$AWK" # Let the user override the test.
11370 else
11371 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11372 for as_dir in $PATH
11373 do
11374   IFS=$as_save_IFS
11375   test -z "$as_dir" && as_dir=.
11376     for ac_exec_ext in '' $ac_executable_extensions; do
11377   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11378     ac_cv_prog_AWK="$ac_prog"
11379     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11380     break 2
11381   fi
11382 done
11383   done
11384 IFS=$as_save_IFS
11385 
11386 fi
11387 fi
11388 AWK=$ac_cv_prog_AWK
11389 if test -n "$AWK"; then
11390   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11391 $as_echo "$AWK" >&6; }
11392 else
11393   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11394 $as_echo "no" >&6; }
11395 fi
11396 
11397 
11398   test -n "$AWK" && break
11399 done
11400 
11401   else
11402     # The variable is set, but is it from the command line or the environment?
11403 
11404     # Try to remove the string !AWK! from our list.
11405     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
11406     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11407       # If it failed, the variable was not from the command line. Ignore it,
11408       # but warn the user (except for BASH, which is always set by the calling BASH).
11409       if test "xAWK" != xBASH; then
11410         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
11411 $as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
11412       fi
11413       # Try to locate tool using the code snippet
11414       for ac_prog in gawk mawk nawk awk
11415 do
11416   # Extract the first word of "$ac_prog", so it can be a program name with args.
11417 set dummy $ac_prog; ac_word=$2
11418 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11419 $as_echo_n "checking for $ac_word... " >&6; }
11420 if ${ac_cv_prog_AWK+:} false; then :
11421   $as_echo_n "(cached) " >&6
11422 else
11423   if test -n "$AWK"; then
11424   ac_cv_prog_AWK="$AWK" # Let the user override the test.
11425 else
11426 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11427 for as_dir in $PATH
11428 do
11429   IFS=$as_save_IFS
11430   test -z "$as_dir" && as_dir=.
11431     for ac_exec_ext in '' $ac_executable_extensions; do
11432   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11433     ac_cv_prog_AWK="$ac_prog"
11434     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11435     break 2
11436   fi
11437 done
11438   done
11439 IFS=$as_save_IFS
11440 
11441 fi
11442 fi
11443 AWK=$ac_cv_prog_AWK
11444 if test -n "$AWK"; then
11445   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11446 $as_echo "$AWK" >&6; }
11447 else
11448   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11449 $as_echo "no" >&6; }
11450 fi
11451 
11452 
11453   test -n "$AWK" && break
11454 done
11455 
11456     else
11457       # If it succeeded, then it was overridden by the user. We will use it
11458       # for the tool.
11459 
11460       # First remove it from the list of overridden variables, so we can test
11461       # for unknown variables in the end.
11462       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11463 
11464       # Check if the provided tool contains a complete path.
11465       tool_specified="$AWK"
11466       tool_basename="${tool_specified##*/}"
11467       if test "x$tool_basename" = "x$tool_specified"; then
11468         # A command without a complete path is provided, search $PATH.
11469         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
11470 $as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
11471         # Extract the first word of "$tool_basename", so it can be a program name with args.
11472 set dummy $tool_basename; ac_word=$2
11473 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11474 $as_echo_n "checking for $ac_word... " >&6; }
11475 if ${ac_cv_path_AWK+:} false; then :
11476   $as_echo_n "(cached) " >&6
11477 else
11478   case $AWK in
11479   [\\/]* | ?:[\\/]*)
11480   ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
11481   ;;
11482   *)
11483   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11484 for as_dir in $PATH
11485 do
11486   IFS=$as_save_IFS
11487   test -z "$as_dir" && as_dir=.
11488     for ac_exec_ext in '' $ac_executable_extensions; do
11489   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11490     ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
11491     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11492     break 2
11493   fi
11494 done
11495   done
11496 IFS=$as_save_IFS
11497 
11498   ;;
11499 esac
11500 fi
11501 AWK=$ac_cv_path_AWK
11502 if test -n "$AWK"; then
11503   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11504 $as_echo "$AWK" >&6; }
11505 else
11506   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11507 $as_echo "no" >&6; }
11508 fi
11509 
11510 
11511         if test "x$AWK" = x; then
11512           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11513         fi
11514       else
11515         # Otherwise we believe it is a complete path. Use it as it is.
11516         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
11517 $as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
11518         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
11519 $as_echo_n "checking for AWK... " >&6; }
11520         if test ! -x "$tool_specified"; then
11521           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11522 $as_echo "not found" >&6; }
11523           as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
11524         fi
11525         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11526 $as_echo "$tool_specified" >&6; }
11527       fi
11528     fi
11529   fi
11530 
11531 
11532   if test "x$AWK" = x; then
11533     as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
11534   fi
11535 
11536 
11537 
11538 
11539   # Publish this variable in the help.
11540 
11541 
11542   if test "x$GREP" = x; then
11543     # The variable is not set by user, try to locate tool using the code snippet
11544     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11545 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11546 if ${ac_cv_path_GREP+:} false; then :
11547   $as_echo_n "(cached) " >&6
11548 else
11549   if test -z "$GREP"; then
11550   ac_path_GREP_found=false
11551   # Loop through the user's path and test for each of PROGNAME-LIST
11552   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11553 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11554 do
11555   IFS=$as_save_IFS
11556   test -z "$as_dir" && as_dir=.
11557     for ac_prog in grep ggrep; do
11558     for ac_exec_ext in '' $ac_executable_extensions; do
11559       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11560       as_fn_executable_p "$ac_path_GREP" || continue
11561 # Check for GNU ac_path_GREP and select it if it is found.
11562   # Check for GNU $ac_path_GREP
11563 case `"$ac_path_GREP" --version 2>&1` in
11564 *GNU*)
11565   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11566 *)
11567   ac_count=0
11568   $as_echo_n 0123456789 >"conftest.in"
11569   while :
11570   do
11571     cat "conftest.in" "conftest.in" >"conftest.tmp"
11572     mv "conftest.tmp" "conftest.in"
11573     cp "conftest.in" "conftest.nl"
11574     $as_echo 'GREP' >> "conftest.nl"
11575     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11576     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11577     as_fn_arith $ac_count + 1 && ac_count=$as_val
11578     if test $ac_count -gt ${ac_path_GREP_max-0}; then
11579       # Best one so far, save it but keep looking for a better one
11580       ac_cv_path_GREP="$ac_path_GREP"
11581       ac_path_GREP_max=$ac_count
11582     fi
11583     # 10*(2^10) chars as input seems more than enough
11584     test $ac_count -gt 10 && break
11585   done
11586   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11587 esac
11588 
11589       $ac_path_GREP_found && break 3
11590     done
11591   done
11592   done
11593 IFS=$as_save_IFS
11594   if test -z "$ac_cv_path_GREP"; then
11595     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11596   fi
11597 else
11598   ac_cv_path_GREP=$GREP
11599 fi
11600 
11601 fi
11602 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11603 $as_echo "$ac_cv_path_GREP" >&6; }
11604  GREP="$ac_cv_path_GREP"
11605 
11606 
11607   else
11608     # The variable is set, but is it from the command line or the environment?
11609 
11610     # Try to remove the string !GREP! from our list.
11611     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
11612     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11613       # If it failed, the variable was not from the command line. Ignore it,
11614       # but warn the user (except for BASH, which is always set by the calling BASH).
11615       if test "xGREP" != xBASH; then
11616         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
11617 $as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
11618       fi
11619       # Try to locate tool using the code snippet
11620       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11621 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11622 if ${ac_cv_path_GREP+:} false; then :
11623   $as_echo_n "(cached) " >&6
11624 else
11625   if test -z "$GREP"; then
11626   ac_path_GREP_found=false
11627   # Loop through the user's path and test for each of PROGNAME-LIST
11628   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11629 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11630 do
11631   IFS=$as_save_IFS
11632   test -z "$as_dir" && as_dir=.
11633     for ac_prog in grep ggrep; do
11634     for ac_exec_ext in '' $ac_executable_extensions; do
11635       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11636       as_fn_executable_p "$ac_path_GREP" || continue
11637 # Check for GNU ac_path_GREP and select it if it is found.
11638   # Check for GNU $ac_path_GREP
11639 case `"$ac_path_GREP" --version 2>&1` in
11640 *GNU*)
11641   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11642 *)
11643   ac_count=0
11644   $as_echo_n 0123456789 >"conftest.in"
11645   while :
11646   do
11647     cat "conftest.in" "conftest.in" >"conftest.tmp"
11648     mv "conftest.tmp" "conftest.in"
11649     cp "conftest.in" "conftest.nl"
11650     $as_echo 'GREP' >> "conftest.nl"
11651     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11652     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11653     as_fn_arith $ac_count + 1 && ac_count=$as_val
11654     if test $ac_count -gt ${ac_path_GREP_max-0}; then
11655       # Best one so far, save it but keep looking for a better one
11656       ac_cv_path_GREP="$ac_path_GREP"
11657       ac_path_GREP_max=$ac_count
11658     fi
11659     # 10*(2^10) chars as input seems more than enough
11660     test $ac_count -gt 10 && break
11661   done
11662   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11663 esac
11664 
11665       $ac_path_GREP_found && break 3
11666     done
11667   done
11668   done
11669 IFS=$as_save_IFS
11670   if test -z "$ac_cv_path_GREP"; then
11671     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11672   fi
11673 else
11674   ac_cv_path_GREP=$GREP
11675 fi
11676 
11677 fi
11678 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11679 $as_echo "$ac_cv_path_GREP" >&6; }
11680  GREP="$ac_cv_path_GREP"
11681 
11682 
11683     else
11684       # If it succeeded, then it was overridden by the user. We will use it
11685       # for the tool.
11686 
11687       # First remove it from the list of overridden variables, so we can test
11688       # for unknown variables in the end.
11689       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11690 
11691       # Check if the provided tool contains a complete path.
11692       tool_specified="$GREP"
11693       tool_basename="${tool_specified##*/}"
11694       if test "x$tool_basename" = "x$tool_specified"; then
11695         # A command without a complete path is provided, search $PATH.
11696         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
11697 $as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
11698         # Extract the first word of "$tool_basename", so it can be a program name with args.
11699 set dummy $tool_basename; ac_word=$2
11700 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11701 $as_echo_n "checking for $ac_word... " >&6; }
11702 if ${ac_cv_path_GREP+:} false; then :
11703   $as_echo_n "(cached) " >&6
11704 else
11705   case $GREP in
11706   [\\/]* | ?:[\\/]*)
11707   ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
11708   ;;
11709   *)
11710   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11711 for as_dir in $PATH
11712 do
11713   IFS=$as_save_IFS
11714   test -z "$as_dir" && as_dir=.
11715     for ac_exec_ext in '' $ac_executable_extensions; do
11716   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11717     ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
11718     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11719     break 2
11720   fi
11721 done
11722   done
11723 IFS=$as_save_IFS
11724 
11725   ;;
11726 esac
11727 fi
11728 GREP=$ac_cv_path_GREP
11729 if test -n "$GREP"; then
11730   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
11731 $as_echo "$GREP" >&6; }
11732 else
11733   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11734 $as_echo "no" >&6; }
11735 fi
11736 
11737 
11738         if test "x$GREP" = x; then
11739           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11740         fi
11741       else
11742         # Otherwise we believe it is a complete path. Use it as it is.
11743         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
11744 $as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
11745         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
11746 $as_echo_n "checking for GREP... " >&6; }
11747         if test ! -x "$tool_specified"; then
11748           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11749 $as_echo "not found" >&6; }
11750           as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
11751         fi
11752         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11753 $as_echo "$tool_specified" >&6; }
11754       fi
11755     fi
11756   fi
11757 
11758 
11759   if test "x$GREP" = x; then
11760     as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
11761   fi
11762 
11763 
11764 
11765 
11766   # Publish this variable in the help.
11767 
11768 
11769   if test "x$EGREP" = x; then
11770     # The variable is not set by user, try to locate tool using the code snippet
11771     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11772 $as_echo_n "checking for egrep... " >&6; }
11773 if ${ac_cv_path_EGREP+:} false; then :
11774   $as_echo_n "(cached) " >&6
11775 else
11776   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11777    then ac_cv_path_EGREP="$GREP -E"
11778    else
11779      if test -z "$EGREP"; then
11780   ac_path_EGREP_found=false
11781   # Loop through the user's path and test for each of PROGNAME-LIST
11782   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11783 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11784 do
11785   IFS=$as_save_IFS
11786   test -z "$as_dir" && as_dir=.
11787     for ac_prog in egrep; do
11788     for ac_exec_ext in '' $ac_executable_extensions; do
11789       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11790       as_fn_executable_p "$ac_path_EGREP" || continue
11791 # Check for GNU ac_path_EGREP and select it if it is found.
11792   # Check for GNU $ac_path_EGREP
11793 case `"$ac_path_EGREP" --version 2>&1` in
11794 *GNU*)
11795   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11796 *)
11797   ac_count=0
11798   $as_echo_n 0123456789 >"conftest.in"
11799   while :
11800   do
11801     cat "conftest.in" "conftest.in" >"conftest.tmp"
11802     mv "conftest.tmp" "conftest.in"
11803     cp "conftest.in" "conftest.nl"
11804     $as_echo 'EGREP' >> "conftest.nl"
11805     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11806     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11807     as_fn_arith $ac_count + 1 && ac_count=$as_val
11808     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11809       # Best one so far, save it but keep looking for a better one
11810       ac_cv_path_EGREP="$ac_path_EGREP"
11811       ac_path_EGREP_max=$ac_count
11812     fi
11813     # 10*(2^10) chars as input seems more than enough
11814     test $ac_count -gt 10 && break
11815   done
11816   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11817 esac
11818 
11819       $ac_path_EGREP_found && break 3
11820     done
11821   done
11822   done
11823 IFS=$as_save_IFS
11824   if test -z "$ac_cv_path_EGREP"; then
11825     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11826   fi
11827 else
11828   ac_cv_path_EGREP=$EGREP
11829 fi
11830 
11831    fi
11832 fi
11833 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11834 $as_echo "$ac_cv_path_EGREP" >&6; }
11835  EGREP="$ac_cv_path_EGREP"
11836 
11837 
11838   else
11839     # The variable is set, but is it from the command line or the environment?
11840 
11841     # Try to remove the string !EGREP! from our list.
11842     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
11843     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11844       # If it failed, the variable was not from the command line. Ignore it,
11845       # but warn the user (except for BASH, which is always set by the calling BASH).
11846       if test "xEGREP" != xBASH; then
11847         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
11848 $as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
11849       fi
11850       # Try to locate tool using the code snippet
11851       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11852 $as_echo_n "checking for egrep... " >&6; }
11853 if ${ac_cv_path_EGREP+:} false; then :
11854   $as_echo_n "(cached) " >&6
11855 else
11856   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11857    then ac_cv_path_EGREP="$GREP -E"
11858    else
11859      if test -z "$EGREP"; then
11860   ac_path_EGREP_found=false
11861   # Loop through the user's path and test for each of PROGNAME-LIST
11862   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11863 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11864 do
11865   IFS=$as_save_IFS
11866   test -z "$as_dir" && as_dir=.
11867     for ac_prog in egrep; do
11868     for ac_exec_ext in '' $ac_executable_extensions; do
11869       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11870       as_fn_executable_p "$ac_path_EGREP" || continue
11871 # Check for GNU ac_path_EGREP and select it if it is found.
11872   # Check for GNU $ac_path_EGREP
11873 case `"$ac_path_EGREP" --version 2>&1` in
11874 *GNU*)
11875   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11876 *)
11877   ac_count=0
11878   $as_echo_n 0123456789 >"conftest.in"
11879   while :
11880   do
11881     cat "conftest.in" "conftest.in" >"conftest.tmp"
11882     mv "conftest.tmp" "conftest.in"
11883     cp "conftest.in" "conftest.nl"
11884     $as_echo 'EGREP' >> "conftest.nl"
11885     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11886     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11887     as_fn_arith $ac_count + 1 && ac_count=$as_val
11888     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11889       # Best one so far, save it but keep looking for a better one
11890       ac_cv_path_EGREP="$ac_path_EGREP"
11891       ac_path_EGREP_max=$ac_count
11892     fi
11893     # 10*(2^10) chars as input seems more than enough
11894     test $ac_count -gt 10 && break
11895   done
11896   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11897 esac
11898 
11899       $ac_path_EGREP_found && break 3
11900     done
11901   done
11902   done
11903 IFS=$as_save_IFS
11904   if test -z "$ac_cv_path_EGREP"; then
11905     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11906   fi
11907 else
11908   ac_cv_path_EGREP=$EGREP
11909 fi
11910 
11911    fi
11912 fi
11913 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11914 $as_echo "$ac_cv_path_EGREP" >&6; }
11915  EGREP="$ac_cv_path_EGREP"
11916 
11917 
11918     else
11919       # If it succeeded, then it was overridden by the user. We will use it
11920       # for the tool.
11921 
11922       # First remove it from the list of overridden variables, so we can test
11923       # for unknown variables in the end.
11924       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11925 
11926       # Check if the provided tool contains a complete path.
11927       tool_specified="$EGREP"
11928       tool_basename="${tool_specified##*/}"
11929       if test "x$tool_basename" = "x$tool_specified"; then
11930         # A command without a complete path is provided, search $PATH.
11931         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
11932 $as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
11933         # Extract the first word of "$tool_basename", so it can be a program name with args.
11934 set dummy $tool_basename; ac_word=$2
11935 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11936 $as_echo_n "checking for $ac_word... " >&6; }
11937 if ${ac_cv_path_EGREP+:} false; then :
11938   $as_echo_n "(cached) " >&6
11939 else
11940   case $EGREP in
11941   [\\/]* | ?:[\\/]*)
11942   ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
11943   ;;
11944   *)
11945   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11946 for as_dir in $PATH
11947 do
11948   IFS=$as_save_IFS
11949   test -z "$as_dir" && as_dir=.
11950     for ac_exec_ext in '' $ac_executable_extensions; do
11951   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11952     ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
11953     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11954     break 2
11955   fi
11956 done
11957   done
11958 IFS=$as_save_IFS
11959 
11960   ;;
11961 esac
11962 fi
11963 EGREP=$ac_cv_path_EGREP
11964 if test -n "$EGREP"; then
11965   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
11966 $as_echo "$EGREP" >&6; }
11967 else
11968   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11969 $as_echo "no" >&6; }
11970 fi
11971 
11972 
11973         if test "x$EGREP" = x; then
11974           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11975         fi
11976       else
11977         # Otherwise we believe it is a complete path. Use it as it is.
11978         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
11979 $as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
11980         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
11981 $as_echo_n "checking for EGREP... " >&6; }
11982         if test ! -x "$tool_specified"; then
11983           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11984 $as_echo "not found" >&6; }
11985           as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
11986         fi
11987         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11988 $as_echo "$tool_specified" >&6; }
11989       fi
11990     fi
11991   fi
11992 
11993 
11994   if test "x$EGREP" = x; then
11995     as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
11996   fi
11997 
11998 
11999 
12000 
12001   # Publish this variable in the help.
12002 
12003 
12004   if test "x$FGREP" = x; then
12005     # The variable is not set by user, try to locate tool using the code snippet
12006     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12007 $as_echo_n "checking for fgrep... " >&6; }
12008 if ${ac_cv_path_FGREP+:} false; then :
12009   $as_echo_n "(cached) " >&6
12010 else
12011   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12012    then ac_cv_path_FGREP="$GREP -F"
12013    else
12014      if test -z "$FGREP"; then
12015   ac_path_FGREP_found=false
12016   # Loop through the user's path and test for each of PROGNAME-LIST
12017   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12018 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12019 do
12020   IFS=$as_save_IFS
12021   test -z "$as_dir" && as_dir=.
12022     for ac_prog in fgrep; do
12023     for ac_exec_ext in '' $ac_executable_extensions; do
12024       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12025       as_fn_executable_p "$ac_path_FGREP" || continue
12026 # Check for GNU ac_path_FGREP and select it if it is found.
12027   # Check for GNU $ac_path_FGREP
12028 case `"$ac_path_FGREP" --version 2>&1` in
12029 *GNU*)
12030   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12031 *)
12032   ac_count=0
12033   $as_echo_n 0123456789 >"conftest.in"
12034   while :
12035   do
12036     cat "conftest.in" "conftest.in" >"conftest.tmp"
12037     mv "conftest.tmp" "conftest.in"
12038     cp "conftest.in" "conftest.nl"
12039     $as_echo 'FGREP' >> "conftest.nl"
12040     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12041     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12042     as_fn_arith $ac_count + 1 && ac_count=$as_val
12043     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12044       # Best one so far, save it but keep looking for a better one
12045       ac_cv_path_FGREP="$ac_path_FGREP"
12046       ac_path_FGREP_max=$ac_count
12047     fi
12048     # 10*(2^10) chars as input seems more than enough
12049     test $ac_count -gt 10 && break
12050   done
12051   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12052 esac
12053 
12054       $ac_path_FGREP_found && break 3
12055     done
12056   done
12057   done
12058 IFS=$as_save_IFS
12059   if test -z "$ac_cv_path_FGREP"; then
12060     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12061   fi
12062 else
12063   ac_cv_path_FGREP=$FGREP
12064 fi
12065 
12066    fi
12067 fi
12068 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12069 $as_echo "$ac_cv_path_FGREP" >&6; }
12070  FGREP="$ac_cv_path_FGREP"
12071 
12072 
12073   else
12074     # The variable is set, but is it from the command line or the environment?
12075 
12076     # Try to remove the string !FGREP! from our list.
12077     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
12078     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12079       # If it failed, the variable was not from the command line. Ignore it,
12080       # but warn the user (except for BASH, which is always set by the calling BASH).
12081       if test "xFGREP" != xBASH; then
12082         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
12083 $as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
12084       fi
12085       # Try to locate tool using the code snippet
12086       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12087 $as_echo_n "checking for fgrep... " >&6; }
12088 if ${ac_cv_path_FGREP+:} false; then :
12089   $as_echo_n "(cached) " >&6
12090 else
12091   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12092    then ac_cv_path_FGREP="$GREP -F"
12093    else
12094      if test -z "$FGREP"; then
12095   ac_path_FGREP_found=false
12096   # Loop through the user's path and test for each of PROGNAME-LIST
12097   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12098 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12099 do
12100   IFS=$as_save_IFS
12101   test -z "$as_dir" && as_dir=.
12102     for ac_prog in fgrep; do
12103     for ac_exec_ext in '' $ac_executable_extensions; do
12104       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12105       as_fn_executable_p "$ac_path_FGREP" || continue
12106 # Check for GNU ac_path_FGREP and select it if it is found.
12107   # Check for GNU $ac_path_FGREP
12108 case `"$ac_path_FGREP" --version 2>&1` in
12109 *GNU*)
12110   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12111 *)
12112   ac_count=0
12113   $as_echo_n 0123456789 >"conftest.in"
12114   while :
12115   do
12116     cat "conftest.in" "conftest.in" >"conftest.tmp"
12117     mv "conftest.tmp" "conftest.in"
12118     cp "conftest.in" "conftest.nl"
12119     $as_echo 'FGREP' >> "conftest.nl"
12120     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12121     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12122     as_fn_arith $ac_count + 1 && ac_count=$as_val
12123     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12124       # Best one so far, save it but keep looking for a better one
12125       ac_cv_path_FGREP="$ac_path_FGREP"
12126       ac_path_FGREP_max=$ac_count
12127     fi
12128     # 10*(2^10) chars as input seems more than enough
12129     test $ac_count -gt 10 && break
12130   done
12131   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12132 esac
12133 
12134       $ac_path_FGREP_found && break 3
12135     done
12136   done
12137   done
12138 IFS=$as_save_IFS
12139   if test -z "$ac_cv_path_FGREP"; then
12140     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12141   fi
12142 else
12143   ac_cv_path_FGREP=$FGREP
12144 fi
12145 
12146    fi
12147 fi
12148 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12149 $as_echo "$ac_cv_path_FGREP" >&6; }
12150  FGREP="$ac_cv_path_FGREP"
12151 
12152 
12153     else
12154       # If it succeeded, then it was overridden by the user. We will use it
12155       # for the tool.
12156 
12157       # First remove it from the list of overridden variables, so we can test
12158       # for unknown variables in the end.
12159       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12160 
12161       # Check if the provided tool contains a complete path.
12162       tool_specified="$FGREP"
12163       tool_basename="${tool_specified##*/}"
12164       if test "x$tool_basename" = "x$tool_specified"; then
12165         # A command without a complete path is provided, search $PATH.
12166         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
12167 $as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
12168         # Extract the first word of "$tool_basename", so it can be a program name with args.
12169 set dummy $tool_basename; ac_word=$2
12170 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12171 $as_echo_n "checking for $ac_word... " >&6; }
12172 if ${ac_cv_path_FGREP+:} false; then :
12173   $as_echo_n "(cached) " >&6
12174 else
12175   case $FGREP in
12176   [\\/]* | ?:[\\/]*)
12177   ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
12178   ;;
12179   *)
12180   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12181 for as_dir in $PATH
12182 do
12183   IFS=$as_save_IFS
12184   test -z "$as_dir" && as_dir=.
12185     for ac_exec_ext in '' $ac_executable_extensions; do
12186   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12187     ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
12188     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12189     break 2
12190   fi
12191 done
12192   done
12193 IFS=$as_save_IFS
12194 
12195   ;;
12196 esac
12197 fi
12198 FGREP=$ac_cv_path_FGREP
12199 if test -n "$FGREP"; then
12200   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
12201 $as_echo "$FGREP" >&6; }
12202 else
12203   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12204 $as_echo "no" >&6; }
12205 fi
12206 
12207 
12208         if test "x$FGREP" = x; then
12209           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12210         fi
12211       else
12212         # Otherwise we believe it is a complete path. Use it as it is.
12213         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
12214 $as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
12215         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
12216 $as_echo_n "checking for FGREP... " >&6; }
12217         if test ! -x "$tool_specified"; then
12218           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12219 $as_echo "not found" >&6; }
12220           as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12221         fi
12222         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12223 $as_echo "$tool_specified" >&6; }
12224       fi
12225     fi
12226   fi
12227 
12228 
12229   if test "x$FGREP" = x; then
12230     as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
12231   fi
12232 
12233 
12234 
12235 
12236   # Publish this variable in the help.
12237 
12238 
12239   if test "x$SED" = x; then
12240     # The variable is not set by user, try to locate tool using the code snippet
12241     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12242 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12243 if ${ac_cv_path_SED+:} false; then :
12244   $as_echo_n "(cached) " >&6
12245 else
12246             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12247      for ac_i in 1 2 3 4 5 6 7; do
12248        ac_script="$ac_script$as_nl$ac_script"
12249      done
12250      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12251      { ac_script=; unset ac_script;}
12252      if test -z "$SED"; then
12253   ac_path_SED_found=false
12254   # Loop through the user's path and test for each of PROGNAME-LIST
12255   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12256 for as_dir in $PATH
12257 do
12258   IFS=$as_save_IFS
12259   test -z "$as_dir" && as_dir=.
12260     for ac_prog in sed gsed; do
12261     for ac_exec_ext in '' $ac_executable_extensions; do
12262       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12263       as_fn_executable_p "$ac_path_SED" || continue
12264 # Check for GNU ac_path_SED and select it if it is found.
12265   # Check for GNU $ac_path_SED
12266 case `"$ac_path_SED" --version 2>&1` in
12267 *GNU*)
12268   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12269 *)
12270   ac_count=0
12271   $as_echo_n 0123456789 >"conftest.in"
12272   while :
12273   do
12274     cat "conftest.in" "conftest.in" >"conftest.tmp"
12275     mv "conftest.tmp" "conftest.in"
12276     cp "conftest.in" "conftest.nl"
12277     $as_echo '' >> "conftest.nl"
12278     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12279     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12280     as_fn_arith $ac_count + 1 && ac_count=$as_val
12281     if test $ac_count -gt ${ac_path_SED_max-0}; then
12282       # Best one so far, save it but keep looking for a better one
12283       ac_cv_path_SED="$ac_path_SED"
12284       ac_path_SED_max=$ac_count
12285     fi
12286     # 10*(2^10) chars as input seems more than enough
12287     test $ac_count -gt 10 && break
12288   done
12289   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12290 esac
12291 
12292       $ac_path_SED_found && break 3
12293     done
12294   done
12295   done
12296 IFS=$as_save_IFS
12297   if test -z "$ac_cv_path_SED"; then
12298     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12299   fi
12300 else
12301   ac_cv_path_SED=$SED
12302 fi
12303 
12304 fi
12305 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12306 $as_echo "$ac_cv_path_SED" >&6; }
12307  SED="$ac_cv_path_SED"
12308   rm -f conftest.sed
12309 
12310   else
12311     # The variable is set, but is it from the command line or the environment?
12312 
12313     # Try to remove the string !SED! from our list.
12314     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
12315     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12316       # If it failed, the variable was not from the command line. Ignore it,
12317       # but warn the user (except for BASH, which is always set by the calling BASH).
12318       if test "xSED" != xBASH; then
12319         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
12320 $as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
12321       fi
12322       # Try to locate tool using the code snippet
12323       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12324 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12325 if ${ac_cv_path_SED+:} false; then :
12326   $as_echo_n "(cached) " >&6
12327 else
12328             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12329      for ac_i in 1 2 3 4 5 6 7; do
12330        ac_script="$ac_script$as_nl$ac_script"
12331      done
12332      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12333      { ac_script=; unset ac_script;}
12334      if test -z "$SED"; then
12335   ac_path_SED_found=false
12336   # Loop through the user's path and test for each of PROGNAME-LIST
12337   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12338 for as_dir in $PATH
12339 do
12340   IFS=$as_save_IFS
12341   test -z "$as_dir" && as_dir=.
12342     for ac_prog in sed gsed; do
12343     for ac_exec_ext in '' $ac_executable_extensions; do
12344       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12345       as_fn_executable_p "$ac_path_SED" || continue
12346 # Check for GNU ac_path_SED and select it if it is found.
12347   # Check for GNU $ac_path_SED
12348 case `"$ac_path_SED" --version 2>&1` in
12349 *GNU*)
12350   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12351 *)
12352   ac_count=0
12353   $as_echo_n 0123456789 >"conftest.in"
12354   while :
12355   do
12356     cat "conftest.in" "conftest.in" >"conftest.tmp"
12357     mv "conftest.tmp" "conftest.in"
12358     cp "conftest.in" "conftest.nl"
12359     $as_echo '' >> "conftest.nl"
12360     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12361     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12362     as_fn_arith $ac_count + 1 && ac_count=$as_val
12363     if test $ac_count -gt ${ac_path_SED_max-0}; then
12364       # Best one so far, save it but keep looking for a better one
12365       ac_cv_path_SED="$ac_path_SED"
12366       ac_path_SED_max=$ac_count
12367     fi
12368     # 10*(2^10) chars as input seems more than enough
12369     test $ac_count -gt 10 && break
12370   done
12371   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12372 esac
12373 
12374       $ac_path_SED_found && break 3
12375     done
12376   done
12377   done
12378 IFS=$as_save_IFS
12379   if test -z "$ac_cv_path_SED"; then
12380     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12381   fi
12382 else
12383   ac_cv_path_SED=$SED
12384 fi
12385 
12386 fi
12387 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12388 $as_echo "$ac_cv_path_SED" >&6; }
12389  SED="$ac_cv_path_SED"
12390   rm -f conftest.sed
12391 
12392     else
12393       # If it succeeded, then it was overridden by the user. We will use it
12394       # for the tool.
12395 
12396       # First remove it from the list of overridden variables, so we can test
12397       # for unknown variables in the end.
12398       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12399 
12400       # Check if the provided tool contains a complete path.
12401       tool_specified="$SED"
12402       tool_basename="${tool_specified##*/}"
12403       if test "x$tool_basename" = "x$tool_specified"; then
12404         # A command without a complete path is provided, search $PATH.
12405         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
12406 $as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
12407         # Extract the first word of "$tool_basename", so it can be a program name with args.
12408 set dummy $tool_basename; ac_word=$2
12409 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12410 $as_echo_n "checking for $ac_word... " >&6; }
12411 if ${ac_cv_path_SED+:} false; then :
12412   $as_echo_n "(cached) " >&6
12413 else
12414   case $SED in
12415   [\\/]* | ?:[\\/]*)
12416   ac_cv_path_SED="$SED" # Let the user override the test with a path.
12417   ;;
12418   *)
12419   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12420 for as_dir in $PATH
12421 do
12422   IFS=$as_save_IFS
12423   test -z "$as_dir" && as_dir=.
12424     for ac_exec_ext in '' $ac_executable_extensions; do
12425   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12426     ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
12427     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12428     break 2
12429   fi
12430 done
12431   done
12432 IFS=$as_save_IFS
12433 
12434   ;;
12435 esac
12436 fi
12437 SED=$ac_cv_path_SED
12438 if test -n "$SED"; then
12439   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
12440 $as_echo "$SED" >&6; }
12441 else
12442   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12443 $as_echo "no" >&6; }
12444 fi
12445 
12446 
12447         if test "x$SED" = x; then
12448           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12449         fi
12450       else
12451         # Otherwise we believe it is a complete path. Use it as it is.
12452         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
12453 $as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
12454         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
12455 $as_echo_n "checking for SED... " >&6; }
12456         if test ! -x "$tool_specified"; then
12457           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12458 $as_echo "not found" >&6; }
12459           as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
12460         fi
12461         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12462 $as_echo "$tool_specified" >&6; }
12463       fi
12464     fi
12465   fi
12466 
12467 
12468   if test "x$SED" = x; then
12469     as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
12470   fi
12471 
12472 
12473 
12474   # Always force rm.
12475   RM="$RM -f"
12476 
12477   # pwd behaves differently on various platforms and some don't support the -L flag.
12478   # Always use the bash builtin pwd to get uniform behavior.
12479   THEPWDCMD=pwd
12480 
12481   # These are not required on all platforms
12482 
12483 
12484   # Publish this variable in the help.
12485 
12486 
12487   if test "x$CYGPATH" = x; then
12488     # The variable is not set by user, try to locate tool using the code snippet
12489     for ac_prog in cygpath
12490 do
12491   # Extract the first word of "$ac_prog", so it can be a program name with args.
12492 set dummy $ac_prog; ac_word=$2
12493 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12494 $as_echo_n "checking for $ac_word... " >&6; }
12495 if ${ac_cv_path_CYGPATH+:} false; then :
12496   $as_echo_n "(cached) " >&6
12497 else
12498   case $CYGPATH in
12499   [\\/]* | ?:[\\/]*)
12500   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12501   ;;
12502   *)
12503   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12504 for as_dir in $PATH
12505 do
12506   IFS=$as_save_IFS
12507   test -z "$as_dir" && as_dir=.
12508     for ac_exec_ext in '' $ac_executable_extensions; do
12509   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12510     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12511     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12512     break 2
12513   fi
12514 done
12515   done
12516 IFS=$as_save_IFS
12517 
12518   ;;
12519 esac
12520 fi
12521 CYGPATH=$ac_cv_path_CYGPATH
12522 if test -n "$CYGPATH"; then
12523   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12524 $as_echo "$CYGPATH" >&6; }
12525 else
12526   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12527 $as_echo "no" >&6; }
12528 fi
12529 
12530 
12531   test -n "$CYGPATH" && break
12532 done
12533 
12534   else
12535     # The variable is set, but is it from the command line or the environment?
12536 
12537     # Try to remove the string !CYGPATH! from our list.
12538     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
12539     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12540       # If it failed, the variable was not from the command line. Ignore it,
12541       # but warn the user (except for BASH, which is always set by the calling BASH).
12542       if test "xCYGPATH" != xBASH; then
12543         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
12544 $as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
12545       fi
12546       # Try to locate tool using the code snippet
12547       for ac_prog in cygpath
12548 do
12549   # Extract the first word of "$ac_prog", so it can be a program name with args.
12550 set dummy $ac_prog; ac_word=$2
12551 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12552 $as_echo_n "checking for $ac_word... " >&6; }
12553 if ${ac_cv_path_CYGPATH+:} false; then :
12554   $as_echo_n "(cached) " >&6
12555 else
12556   case $CYGPATH in
12557   [\\/]* | ?:[\\/]*)
12558   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12559   ;;
12560   *)
12561   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12562 for as_dir in $PATH
12563 do
12564   IFS=$as_save_IFS
12565   test -z "$as_dir" && as_dir=.
12566     for ac_exec_ext in '' $ac_executable_extensions; do
12567   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12568     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12569     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12570     break 2
12571   fi
12572 done
12573   done
12574 IFS=$as_save_IFS
12575 
12576   ;;
12577 esac
12578 fi
12579 CYGPATH=$ac_cv_path_CYGPATH
12580 if test -n "$CYGPATH"; then
12581   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12582 $as_echo "$CYGPATH" >&6; }
12583 else
12584   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12585 $as_echo "no" >&6; }
12586 fi
12587 
12588 
12589   test -n "$CYGPATH" && break
12590 done
12591 
12592     else
12593       # If it succeeded, then it was overridden by the user. We will use it
12594       # for the tool.
12595 
12596       # First remove it from the list of overridden variables, so we can test
12597       # for unknown variables in the end.
12598       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12599 
12600       # Check if the provided tool contains a complete path.
12601       tool_specified="$CYGPATH"
12602       tool_basename="${tool_specified##*/}"
12603       if test "x$tool_basename" = "x$tool_specified"; then
12604         # A command without a complete path is provided, search $PATH.
12605         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
12606 $as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
12607         # Extract the first word of "$tool_basename", so it can be a program name with args.
12608 set dummy $tool_basename; ac_word=$2
12609 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12610 $as_echo_n "checking for $ac_word... " >&6; }
12611 if ${ac_cv_path_CYGPATH+:} false; then :
12612   $as_echo_n "(cached) " >&6
12613 else
12614   case $CYGPATH in
12615   [\\/]* | ?:[\\/]*)
12616   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12617   ;;
12618   *)
12619   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12620 for as_dir in $PATH
12621 do
12622   IFS=$as_save_IFS
12623   test -z "$as_dir" && as_dir=.
12624     for ac_exec_ext in '' $ac_executable_extensions; do
12625   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12626     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12627     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12628     break 2
12629   fi
12630 done
12631   done
12632 IFS=$as_save_IFS
12633 
12634   ;;
12635 esac
12636 fi
12637 CYGPATH=$ac_cv_path_CYGPATH
12638 if test -n "$CYGPATH"; then
12639   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12640 $as_echo "$CYGPATH" >&6; }
12641 else
12642   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12643 $as_echo "no" >&6; }
12644 fi
12645 
12646 
12647         if test "x$CYGPATH" = x; then
12648           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12649         fi
12650       else
12651         # Otherwise we believe it is a complete path. Use it as it is.
12652         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
12653 $as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
12654         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
12655 $as_echo_n "checking for CYGPATH... " >&6; }
12656         if test ! -x "$tool_specified"; then
12657           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12658 $as_echo "not found" >&6; }
12659           as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
12660         fi
12661         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12662 $as_echo "$tool_specified" >&6; }
12663       fi
12664     fi
12665   fi
12666 
12667 
12668 
12669 
12670   # Publish this variable in the help.
12671 
12672 
12673   if test "x$READLINK" = x; then
12674     # The variable is not set by user, try to locate tool using the code snippet
12675     for ac_prog in greadlink readlink
12676 do
12677   # Extract the first word of "$ac_prog", so it can be a program name with args.
12678 set dummy $ac_prog; ac_word=$2
12679 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12680 $as_echo_n "checking for $ac_word... " >&6; }
12681 if ${ac_cv_path_READLINK+:} false; then :
12682   $as_echo_n "(cached) " >&6
12683 else
12684   case $READLINK in
12685   [\\/]* | ?:[\\/]*)
12686   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12687   ;;
12688   *)
12689   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12690 for as_dir in $PATH
12691 do
12692   IFS=$as_save_IFS
12693   test -z "$as_dir" && as_dir=.
12694     for ac_exec_ext in '' $ac_executable_extensions; do
12695   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12696     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12697     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12698     break 2
12699   fi
12700 done
12701   done
12702 IFS=$as_save_IFS
12703 
12704   ;;
12705 esac
12706 fi
12707 READLINK=$ac_cv_path_READLINK
12708 if test -n "$READLINK"; then
12709   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12710 $as_echo "$READLINK" >&6; }
12711 else
12712   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12713 $as_echo "no" >&6; }
12714 fi
12715 
12716 
12717   test -n "$READLINK" && break
12718 done
12719 
12720   else
12721     # The variable is set, but is it from the command line or the environment?
12722 
12723     # Try to remove the string !READLINK! from our list.
12724     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
12725     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12726       # If it failed, the variable was not from the command line. Ignore it,
12727       # but warn the user (except for BASH, which is always set by the calling BASH).
12728       if test "xREADLINK" != xBASH; then
12729         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
12730 $as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
12731       fi
12732       # Try to locate tool using the code snippet
12733       for ac_prog in greadlink readlink
12734 do
12735   # Extract the first word of "$ac_prog", so it can be a program name with args.
12736 set dummy $ac_prog; ac_word=$2
12737 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12738 $as_echo_n "checking for $ac_word... " >&6; }
12739 if ${ac_cv_path_READLINK+:} false; then :
12740   $as_echo_n "(cached) " >&6
12741 else
12742   case $READLINK in
12743   [\\/]* | ?:[\\/]*)
12744   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12745   ;;
12746   *)
12747   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12748 for as_dir in $PATH
12749 do
12750   IFS=$as_save_IFS
12751   test -z "$as_dir" && as_dir=.
12752     for ac_exec_ext in '' $ac_executable_extensions; do
12753   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12754     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12755     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12756     break 2
12757   fi
12758 done
12759   done
12760 IFS=$as_save_IFS
12761 
12762   ;;
12763 esac
12764 fi
12765 READLINK=$ac_cv_path_READLINK
12766 if test -n "$READLINK"; then
12767   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12768 $as_echo "$READLINK" >&6; }
12769 else
12770   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12771 $as_echo "no" >&6; }
12772 fi
12773 
12774 
12775   test -n "$READLINK" && break
12776 done
12777 
12778     else
12779       # If it succeeded, then it was overridden by the user. We will use it
12780       # for the tool.
12781 
12782       # First remove it from the list of overridden variables, so we can test
12783       # for unknown variables in the end.
12784       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12785 
12786       # Check if the provided tool contains a complete path.
12787       tool_specified="$READLINK"
12788       tool_basename="${tool_specified##*/}"
12789       if test "x$tool_basename" = "x$tool_specified"; then
12790         # A command without a complete path is provided, search $PATH.
12791         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
12792 $as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
12793         # Extract the first word of "$tool_basename", so it can be a program name with args.
12794 set dummy $tool_basename; ac_word=$2
12795 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12796 $as_echo_n "checking for $ac_word... " >&6; }
12797 if ${ac_cv_path_READLINK+:} false; then :
12798   $as_echo_n "(cached) " >&6
12799 else
12800   case $READLINK in
12801   [\\/]* | ?:[\\/]*)
12802   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12803   ;;
12804   *)
12805   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12806 for as_dir in $PATH
12807 do
12808   IFS=$as_save_IFS
12809   test -z "$as_dir" && as_dir=.
12810     for ac_exec_ext in '' $ac_executable_extensions; do
12811   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12812     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12813     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12814     break 2
12815   fi
12816 done
12817   done
12818 IFS=$as_save_IFS
12819 
12820   ;;
12821 esac
12822 fi
12823 READLINK=$ac_cv_path_READLINK
12824 if test -n "$READLINK"; then
12825   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12826 $as_echo "$READLINK" >&6; }
12827 else
12828   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12829 $as_echo "no" >&6; }
12830 fi
12831 
12832 
12833         if test "x$READLINK" = x; then
12834           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12835         fi
12836       else
12837         # Otherwise we believe it is a complete path. Use it as it is.
12838         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
12839 $as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
12840         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
12841 $as_echo_n "checking for READLINK... " >&6; }
12842         if test ! -x "$tool_specified"; then
12843           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12844 $as_echo "not found" >&6; }
12845           as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
12846         fi
12847         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12848 $as_echo "$tool_specified" >&6; }
12849       fi
12850     fi
12851   fi
12852 
12853 
12854 
12855 
12856   # Publish this variable in the help.
12857 
12858 
12859   if test "x$DF" = x; then
12860     # The variable is not set by user, try to locate tool using the code snippet
12861     for ac_prog in df
12862 do
12863   # Extract the first word of "$ac_prog", so it can be a program name with args.
12864 set dummy $ac_prog; ac_word=$2
12865 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12866 $as_echo_n "checking for $ac_word... " >&6; }
12867 if ${ac_cv_path_DF+:} false; then :
12868   $as_echo_n "(cached) " >&6
12869 else
12870   case $DF in
12871   [\\/]* | ?:[\\/]*)
12872   ac_cv_path_DF="$DF" # Let the user override the test with a path.
12873   ;;
12874   *)
12875   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12876 for as_dir in $PATH
12877 do
12878   IFS=$as_save_IFS
12879   test -z "$as_dir" && as_dir=.
12880     for ac_exec_ext in '' $ac_executable_extensions; do
12881   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12882     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12883     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12884     break 2
12885   fi
12886 done
12887   done
12888 IFS=$as_save_IFS
12889 
12890   ;;
12891 esac
12892 fi
12893 DF=$ac_cv_path_DF
12894 if test -n "$DF"; then
12895   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12896 $as_echo "$DF" >&6; }
12897 else
12898   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12899 $as_echo "no" >&6; }
12900 fi
12901 
12902 
12903   test -n "$DF" && break
12904 done
12905 
12906   else
12907     # The variable is set, but is it from the command line or the environment?
12908 
12909     # Try to remove the string !DF! from our list.
12910     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
12911     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12912       # If it failed, the variable was not from the command line. Ignore it,
12913       # but warn the user (except for BASH, which is always set by the calling BASH).
12914       if test "xDF" != xBASH; then
12915         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
12916 $as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
12917       fi
12918       # Try to locate tool using the code snippet
12919       for ac_prog in df
12920 do
12921   # Extract the first word of "$ac_prog", so it can be a program name with args.
12922 set dummy $ac_prog; ac_word=$2
12923 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12924 $as_echo_n "checking for $ac_word... " >&6; }
12925 if ${ac_cv_path_DF+:} false; then :
12926   $as_echo_n "(cached) " >&6
12927 else
12928   case $DF in
12929   [\\/]* | ?:[\\/]*)
12930   ac_cv_path_DF="$DF" # Let the user override the test with a path.
12931   ;;
12932   *)
12933   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12934 for as_dir in $PATH
12935 do
12936   IFS=$as_save_IFS
12937   test -z "$as_dir" && as_dir=.
12938     for ac_exec_ext in '' $ac_executable_extensions; do
12939   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12940     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12941     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12942     break 2
12943   fi
12944 done
12945   done
12946 IFS=$as_save_IFS
12947 
12948   ;;
12949 esac
12950 fi
12951 DF=$ac_cv_path_DF
12952 if test -n "$DF"; then
12953   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12954 $as_echo "$DF" >&6; }
12955 else
12956   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12957 $as_echo "no" >&6; }
12958 fi
12959 
12960 
12961   test -n "$DF" && break
12962 done
12963 
12964     else
12965       # If it succeeded, then it was overridden by the user. We will use it
12966       # for the tool.
12967 
12968       # First remove it from the list of overridden variables, so we can test
12969       # for unknown variables in the end.
12970       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12971 
12972       # Check if the provided tool contains a complete path.
12973       tool_specified="$DF"
12974       tool_basename="${tool_specified##*/}"
12975       if test "x$tool_basename" = "x$tool_specified"; then
12976         # A command without a complete path is provided, search $PATH.
12977         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
12978 $as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
12979         # Extract the first word of "$tool_basename", so it can be a program name with args.
12980 set dummy $tool_basename; ac_word=$2
12981 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12982 $as_echo_n "checking for $ac_word... " >&6; }
12983 if ${ac_cv_path_DF+:} false; then :
12984   $as_echo_n "(cached) " >&6
12985 else
12986   case $DF in
12987   [\\/]* | ?:[\\/]*)
12988   ac_cv_path_DF="$DF" # Let the user override the test with a path.
12989   ;;
12990   *)
12991   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12992 for as_dir in $PATH
12993 do
12994   IFS=$as_save_IFS
12995   test -z "$as_dir" && as_dir=.
12996     for ac_exec_ext in '' $ac_executable_extensions; do
12997   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12998     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12999     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13000     break 2
13001   fi
13002 done
13003   done
13004 IFS=$as_save_IFS
13005 
13006   ;;
13007 esac
13008 fi
13009 DF=$ac_cv_path_DF
13010 if test -n "$DF"; then
13011   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
13012 $as_echo "$DF" >&6; }
13013 else
13014   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13015 $as_echo "no" >&6; }
13016 fi
13017 
13018 
13019         if test "x$DF" = x; then
13020           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13021         fi
13022       else
13023         # Otherwise we believe it is a complete path. Use it as it is.
13024         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
13025 $as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
13026         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
13027 $as_echo_n "checking for DF... " >&6; }
13028         if test ! -x "$tool_specified"; then
13029           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13030 $as_echo "not found" >&6; }
13031           as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
13032         fi
13033         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13034 $as_echo "$tool_specified" >&6; }
13035       fi
13036     fi
13037   fi
13038 
13039 
13040 
13041 
13042   # Publish this variable in the help.
13043 
13044 
13045   if test "x$SETFILE" = x; then
13046     # The variable is not set by user, try to locate tool using the code snippet
13047     for ac_prog in SetFile
13048 do
13049   # Extract the first word of "$ac_prog", so it can be a program name with args.
13050 set dummy $ac_prog; ac_word=$2
13051 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13052 $as_echo_n "checking for $ac_word... " >&6; }
13053 if ${ac_cv_path_SETFILE+:} false; then :
13054   $as_echo_n "(cached) " >&6
13055 else
13056   case $SETFILE in
13057   [\\/]* | ?:[\\/]*)
13058   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13059   ;;
13060   *)
13061   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13062 for as_dir in $PATH
13063 do
13064   IFS=$as_save_IFS
13065   test -z "$as_dir" && as_dir=.
13066     for ac_exec_ext in '' $ac_executable_extensions; do
13067   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13068     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13069     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13070     break 2
13071   fi
13072 done
13073   done
13074 IFS=$as_save_IFS
13075 
13076   ;;
13077 esac
13078 fi
13079 SETFILE=$ac_cv_path_SETFILE
13080 if test -n "$SETFILE"; then
13081   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13082 $as_echo "$SETFILE" >&6; }
13083 else
13084   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13085 $as_echo "no" >&6; }
13086 fi
13087 
13088 
13089   test -n "$SETFILE" && break
13090 done
13091 
13092   else
13093     # The variable is set, but is it from the command line or the environment?
13094 
13095     # Try to remove the string !SETFILE! from our list.
13096     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
13097     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13098       # If it failed, the variable was not from the command line. Ignore it,
13099       # but warn the user (except for BASH, which is always set by the calling BASH).
13100       if test "xSETFILE" != xBASH; then
13101         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
13102 $as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
13103       fi
13104       # Try to locate tool using the code snippet
13105       for ac_prog in SetFile
13106 do
13107   # Extract the first word of "$ac_prog", so it can be a program name with args.
13108 set dummy $ac_prog; ac_word=$2
13109 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13110 $as_echo_n "checking for $ac_word... " >&6; }
13111 if ${ac_cv_path_SETFILE+:} false; then :
13112   $as_echo_n "(cached) " >&6
13113 else
13114   case $SETFILE in
13115   [\\/]* | ?:[\\/]*)
13116   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13117   ;;
13118   *)
13119   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13120 for as_dir in $PATH
13121 do
13122   IFS=$as_save_IFS
13123   test -z "$as_dir" && as_dir=.
13124     for ac_exec_ext in '' $ac_executable_extensions; do
13125   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13126     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13127     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13128     break 2
13129   fi
13130 done
13131   done
13132 IFS=$as_save_IFS
13133 
13134   ;;
13135 esac
13136 fi
13137 SETFILE=$ac_cv_path_SETFILE
13138 if test -n "$SETFILE"; then
13139   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13140 $as_echo "$SETFILE" >&6; }
13141 else
13142   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13143 $as_echo "no" >&6; }
13144 fi
13145 
13146 
13147   test -n "$SETFILE" && break
13148 done
13149 
13150     else
13151       # If it succeeded, then it was overridden by the user. We will use it
13152       # for the tool.
13153 
13154       # First remove it from the list of overridden variables, so we can test
13155       # for unknown variables in the end.
13156       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13157 
13158       # Check if the provided tool contains a complete path.
13159       tool_specified="$SETFILE"
13160       tool_basename="${tool_specified##*/}"
13161       if test "x$tool_basename" = "x$tool_specified"; then
13162         # A command without a complete path is provided, search $PATH.
13163         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
13164 $as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
13165         # Extract the first word of "$tool_basename", so it can be a program name with args.
13166 set dummy $tool_basename; ac_word=$2
13167 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13168 $as_echo_n "checking for $ac_word... " >&6; }
13169 if ${ac_cv_path_SETFILE+:} false; then :
13170   $as_echo_n "(cached) " >&6
13171 else
13172   case $SETFILE in
13173   [\\/]* | ?:[\\/]*)
13174   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13175   ;;
13176   *)
13177   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13178 for as_dir in $PATH
13179 do
13180   IFS=$as_save_IFS
13181   test -z "$as_dir" && as_dir=.
13182     for ac_exec_ext in '' $ac_executable_extensions; do
13183   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13184     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13185     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13186     break 2
13187   fi
13188 done
13189   done
13190 IFS=$as_save_IFS
13191 
13192   ;;
13193 esac
13194 fi
13195 SETFILE=$ac_cv_path_SETFILE
13196 if test -n "$SETFILE"; then
13197   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13198 $as_echo "$SETFILE" >&6; }
13199 else
13200   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13201 $as_echo "no" >&6; }
13202 fi
13203 
13204 
13205         if test "x$SETFILE" = x; then
13206           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13207         fi
13208       else
13209         # Otherwise we believe it is a complete path. Use it as it is.
13210         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
13211 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
13212         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
13213 $as_echo_n "checking for SETFILE... " >&6; }
13214         if test ! -x "$tool_specified"; then
13215           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13216 $as_echo "not found" >&6; }
13217           as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
13218         fi
13219         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13220 $as_echo "$tool_specified" >&6; }
13221       fi
13222     fi
13223   fi
13224 
13225 
13226 
13227 
13228   # Publish this variable in the help.
13229 
13230 
13231   if test "x$CPIO" = x; then
13232     # The variable is not set by user, try to locate tool using the code snippet
13233     for ac_prog in cpio bsdcpio
13234 do
13235   # Extract the first word of "$ac_prog", so it can be a program name with args.
13236 set dummy $ac_prog; ac_word=$2
13237 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13238 $as_echo_n "checking for $ac_word... " >&6; }
13239 if ${ac_cv_path_CPIO+:} false; then :
13240   $as_echo_n "(cached) " >&6
13241 else
13242   case $CPIO in
13243   [\\/]* | ?:[\\/]*)
13244   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13245   ;;
13246   *)
13247   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13248 for as_dir in $PATH
13249 do
13250   IFS=$as_save_IFS
13251   test -z "$as_dir" && as_dir=.
13252     for ac_exec_ext in '' $ac_executable_extensions; do
13253   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13254     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13255     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13256     break 2
13257   fi
13258 done
13259   done
13260 IFS=$as_save_IFS
13261 
13262   ;;
13263 esac
13264 fi
13265 CPIO=$ac_cv_path_CPIO
13266 if test -n "$CPIO"; then
13267   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13268 $as_echo "$CPIO" >&6; }
13269 else
13270   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13271 $as_echo "no" >&6; }
13272 fi
13273 
13274 
13275   test -n "$CPIO" && break
13276 done
13277 
13278   else
13279     # The variable is set, but is it from the command line or the environment?
13280 
13281     # Try to remove the string !CPIO! from our list.
13282     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
13283     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13284       # If it failed, the variable was not from the command line. Ignore it,
13285       # but warn the user (except for BASH, which is always set by the calling BASH).
13286       if test "xCPIO" != xBASH; then
13287         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
13288 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
13289       fi
13290       # Try to locate tool using the code snippet
13291       for ac_prog in cpio bsdcpio
13292 do
13293   # Extract the first word of "$ac_prog", so it can be a program name with args.
13294 set dummy $ac_prog; ac_word=$2
13295 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13296 $as_echo_n "checking for $ac_word... " >&6; }
13297 if ${ac_cv_path_CPIO+:} false; then :
13298   $as_echo_n "(cached) " >&6
13299 else
13300   case $CPIO in
13301   [\\/]* | ?:[\\/]*)
13302   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13303   ;;
13304   *)
13305   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13306 for as_dir in $PATH
13307 do
13308   IFS=$as_save_IFS
13309   test -z "$as_dir" && as_dir=.
13310     for ac_exec_ext in '' $ac_executable_extensions; do
13311   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13312     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13313     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13314     break 2
13315   fi
13316 done
13317   done
13318 IFS=$as_save_IFS
13319 
13320   ;;
13321 esac
13322 fi
13323 CPIO=$ac_cv_path_CPIO
13324 if test -n "$CPIO"; then
13325   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13326 $as_echo "$CPIO" >&6; }
13327 else
13328   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13329 $as_echo "no" >&6; }
13330 fi
13331 
13332 
13333   test -n "$CPIO" && break
13334 done
13335 
13336     else
13337       # If it succeeded, then it was overridden by the user. We will use it
13338       # for the tool.
13339 
13340       # First remove it from the list of overridden variables, so we can test
13341       # for unknown variables in the end.
13342       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13343 
13344       # Check if the provided tool contains a complete path.
13345       tool_specified="$CPIO"
13346       tool_basename="${tool_specified##*/}"
13347       if test "x$tool_basename" = "x$tool_specified"; then
13348         # A command without a complete path is provided, search $PATH.
13349         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
13350 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
13351         # Extract the first word of "$tool_basename", so it can be a program name with args.
13352 set dummy $tool_basename; ac_word=$2
13353 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13354 $as_echo_n "checking for $ac_word... " >&6; }
13355 if ${ac_cv_path_CPIO+:} false; then :
13356   $as_echo_n "(cached) " >&6
13357 else
13358   case $CPIO in
13359   [\\/]* | ?:[\\/]*)
13360   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13361   ;;
13362   *)
13363   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13364 for as_dir in $PATH
13365 do
13366   IFS=$as_save_IFS
13367   test -z "$as_dir" && as_dir=.
13368     for ac_exec_ext in '' $ac_executable_extensions; do
13369   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13370     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13371     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13372     break 2
13373   fi
13374 done
13375   done
13376 IFS=$as_save_IFS
13377 
13378   ;;
13379 esac
13380 fi
13381 CPIO=$ac_cv_path_CPIO
13382 if test -n "$CPIO"; then
13383   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13384 $as_echo "$CPIO" >&6; }
13385 else
13386   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13387 $as_echo "no" >&6; }
13388 fi
13389 
13390 
13391         if test "x$CPIO" = x; then
13392           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13393         fi
13394       else
13395         # Otherwise we believe it is a complete path. Use it as it is.
13396         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
13397 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
13398         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
13399 $as_echo_n "checking for CPIO... " >&6; }
13400         if test ! -x "$tool_specified"; then
13401           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13402 $as_echo "not found" >&6; }
13403           as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
13404         fi
13405         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13406 $as_echo "$tool_specified" >&6; }
13407       fi
13408     fi
13409   fi
13410 
13411 
13412 
13413 
13414 # Now we can determine OpenJDK build and target platforms. This is required to
13415 # have early on.
13416 # Make sure we can run config.sub.
13417 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
13418   as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
13419 
13420 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
13421 $as_echo_n "checking build system type... " >&6; }
13422 if ${ac_cv_build+:} false; then :
13423   $as_echo_n "(cached) " >&6
13424 else
13425   ac_build_alias=$build_alias
13426 test "x$ac_build_alias" = x &&
13427   ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
13428 test "x$ac_build_alias" = x &&
13429   as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
13430 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
13431   as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
13432 
13433 fi
13434 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
13435 $as_echo "$ac_cv_build" >&6; }
13436 case $ac_cv_build in
13437 *-*-*) ;;
13438 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
13439 esac
13440 build=$ac_cv_build
13441 ac_save_IFS=$IFS; IFS='-'
13442 set x $ac_cv_build
13443 shift
13444 build_cpu=$1
13445 build_vendor=$2
13446 shift; shift
13447 # Remember, the first character of IFS is used to create $*,
13448 # except with old shells:
13449 build_os=$*
13450 IFS=$ac_save_IFS
13451 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
13452 
13453 
13454 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
13455 $as_echo_n "checking host system type... " >&6; }
13456 if ${ac_cv_host+:} false; then :
13457   $as_echo_n "(cached) " >&6
13458 else
13459   if test "x$host_alias" = x; then
13460   ac_cv_host=$ac_cv_build
13461 else
13462   ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
13463     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
13464 fi
13465 
13466 fi
13467 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
13468 $as_echo "$ac_cv_host" >&6; }
13469 case $ac_cv_host in
13470 *-*-*) ;;
13471 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
13472 esac
13473 host=$ac_cv_host
13474 ac_save_IFS=$IFS; IFS='-'
13475 set x $ac_cv_host
13476 shift
13477 host_cpu=$1
13478 host_vendor=$2
13479 shift; shift
13480 # Remember, the first character of IFS is used to create $*,
13481 # except with old shells:
13482 host_os=$*
13483 IFS=$ac_save_IFS
13484 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
13485 
13486 
13487 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
13488 $as_echo_n "checking target system type... " >&6; }
13489 if ${ac_cv_target+:} false; then :
13490   $as_echo_n "(cached) " >&6
13491 else
13492   if test "x$target_alias" = x; then
13493   ac_cv_target=$ac_cv_host
13494 else
13495   ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
13496     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
13497 fi
13498 
13499 fi
13500 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
13501 $as_echo "$ac_cv_target" >&6; }
13502 case $ac_cv_target in
13503 *-*-*) ;;
13504 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
13505 esac
13506 target=$ac_cv_target
13507 ac_save_IFS=$IFS; IFS='-'
13508 set x $ac_cv_target
13509 shift
13510 target_cpu=$1
13511 target_vendor=$2
13512 shift; shift
13513 # Remember, the first character of IFS is used to create $*,
13514 # except with old shells:
13515 target_os=$*
13516 IFS=$ac_save_IFS
13517 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
13518 
13519 
13520 # The aliases save the names the user supplied, while $host etc.
13521 # will get canonicalized.
13522 test -n "$target_alias" &&
13523   test "$program_prefix$program_suffix$program_transform_name" = \
13524     NONENONEs,x,x, &&
13525   program_prefix=${target_alias}-
13526 
13527   # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
13528   # is confusing; it assumes you are cross-compiling a cross-compiler (!)  and "target" is thus the target of the
13529   # product you're building. The target of this build is called "host". Since this is confusing to most people, we
13530   # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
13531   # to use the configure naming style.
13532 
13533 
13534 
13535 
13536 
13537   # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
13538   # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
13539   # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
13540   # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
13541   OPENJDK_TARGET_AUTOCONF_NAME="$host"
13542   OPENJDK_BUILD_AUTOCONF_NAME="$build"
13543 
13544 
13545 
13546   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13547 
13548   case "$build_os" in
13549     *linux*)
13550       VAR_OS=linux
13551       VAR_OS_TYPE=unix
13552       ;;
13553     *solaris*)
13554       VAR_OS=solaris
13555       VAR_OS_TYPE=unix
13556       ;;
13557     *darwin*)
13558       VAR_OS=macosx
13559       VAR_OS_TYPE=unix
13560       ;;
13561     *bsd*)
13562       VAR_OS=bsd
13563       VAR_OS_TYPE=unix
13564       ;;
13565     *cygwin*)
13566       VAR_OS=windows
13567       VAR_OS_ENV=windows.cygwin
13568       ;;
13569     *mingw*)
13570       VAR_OS=windows
13571       VAR_OS_ENV=windows.msys
13572       ;;
13573     *aix*)
13574       VAR_OS=aix
13575       VAR_OS_TYPE=unix
13576       ;;
13577     *)
13578       as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
13579       ;;
13580   esac
13581 
13582 
13583   # First argument is the cpu name from the trip/quad
13584   case "$build_cpu" in
13585     x86_64)
13586       VAR_CPU=x86_64
13587       VAR_CPU_ARCH=x86
13588       VAR_CPU_BITS=64
13589       VAR_CPU_ENDIAN=little
13590       ;;
13591     i?86)
13592       VAR_CPU=x86
13593       VAR_CPU_ARCH=x86
13594       VAR_CPU_BITS=32
13595       VAR_CPU_ENDIAN=little
13596       ;;
13597     arm*)
13598       VAR_CPU=arm
13599       VAR_CPU_ARCH=arm
13600       VAR_CPU_BITS=32
13601       VAR_CPU_ENDIAN=little
13602       ;;
13603     aarch64)
13604       VAR_CPU=aarch64
13605       VAR_CPU_ARCH=aarch64
13606       VAR_CPU_BITS=64
13607       VAR_CPU_ENDIAN=little
13608       ;;
13609     powerpc)
13610       VAR_CPU=ppc
13611       VAR_CPU_ARCH=ppc
13612       VAR_CPU_BITS=32
13613       VAR_CPU_ENDIAN=big
13614       ;;
13615     powerpc64)
13616       VAR_CPU=ppc64
13617       VAR_CPU_ARCH=ppc
13618       VAR_CPU_BITS=64
13619       VAR_CPU_ENDIAN=big
13620       ;;
13621     powerpc64le)
13622       VAR_CPU=ppc64
13623       VAR_CPU_ARCH=ppc
13624       VAR_CPU_BITS=64
13625       VAR_CPU_ENDIAN=little
13626       ;;
13627     s390)
13628       VAR_CPU=s390
13629       VAR_CPU_ARCH=s390
13630       VAR_CPU_BITS=32
13631       VAR_CPU_ENDIAN=big
13632       ;;
13633     s390x)
13634       VAR_CPU=s390x
13635       VAR_CPU_ARCH=s390
13636       VAR_CPU_BITS=64
13637       VAR_CPU_ENDIAN=big
13638       ;;
13639     sparc)
13640       VAR_CPU=sparc
13641       VAR_CPU_ARCH=sparc
13642       VAR_CPU_BITS=32
13643       VAR_CPU_ENDIAN=big
13644       ;;
13645     sparcv9|sparc64)
13646       VAR_CPU=sparcv9
13647       VAR_CPU_ARCH=sparc
13648       VAR_CPU_BITS=64
13649       VAR_CPU_ENDIAN=big
13650       ;;
13651     *)
13652       as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
13653       ;;
13654   esac
13655 
13656   # ..and setup our own variables. (Do this explicitely to facilitate searching)
13657   OPENJDK_BUILD_OS="$VAR_OS"
13658   if test "x$VAR_OS_TYPE" != x; then
13659     OPENJDK_BUILD_OS_TYPE="$VAR_OS_TYPE"
13660   else
13661     OPENJDK_BUILD_OS_TYPE="$VAR_OS"
13662   fi
13663   if test "x$VAR_OS_ENV" != x; then
13664     OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
13665   else
13666     OPENJDK_BUILD_OS_ENV="$VAR_OS"
13667   fi
13668   OPENJDK_BUILD_CPU="$VAR_CPU"
13669   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
13670   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
13671   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13672 
13673 
13674 
13675 
13676 
13677 
13678 
13679 
13680   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
13681 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
13682   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
13683 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
13684 
13685   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13686 
13687   case "$host_os" in
13688     *linux*)
13689       VAR_OS=linux
13690       VAR_OS_TYPE=unix
13691       ;;
13692     *solaris*)
13693       VAR_OS=solaris
13694       VAR_OS_TYPE=unix
13695       ;;
13696     *darwin*)
13697       VAR_OS=macosx
13698       VAR_OS_TYPE=unix
13699       ;;
13700     *bsd*)
13701       VAR_OS=bsd
13702       VAR_OS_TYPE=unix
13703       ;;
13704     *cygwin*)
13705       VAR_OS=windows
13706       VAR_OS_ENV=windows.cygwin
13707       ;;
13708     *mingw*)
13709       VAR_OS=windows
13710       VAR_OS_ENV=windows.msys
13711       ;;
13712     *aix*)
13713       VAR_OS=aix
13714       VAR_OS_TYPE=unix
13715       ;;
13716     *)
13717       as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
13718       ;;
13719   esac
13720 
13721 
13722   # First argument is the cpu name from the trip/quad
13723   case "$host_cpu" in
13724     x86_64)
13725       VAR_CPU=x86_64
13726       VAR_CPU_ARCH=x86
13727       VAR_CPU_BITS=64
13728       VAR_CPU_ENDIAN=little
13729       ;;
13730     i?86)
13731       VAR_CPU=x86
13732       VAR_CPU_ARCH=x86
13733       VAR_CPU_BITS=32
13734       VAR_CPU_ENDIAN=little
13735       ;;
13736     arm*)
13737       VAR_CPU=arm
13738       VAR_CPU_ARCH=arm
13739       VAR_CPU_BITS=32
13740       VAR_CPU_ENDIAN=little
13741       ;;
13742     aarch64)
13743       VAR_CPU=aarch64
13744       VAR_CPU_ARCH=aarch64
13745       VAR_CPU_BITS=64
13746       VAR_CPU_ENDIAN=little
13747       ;;
13748     powerpc)
13749       VAR_CPU=ppc
13750       VAR_CPU_ARCH=ppc
13751       VAR_CPU_BITS=32
13752       VAR_CPU_ENDIAN=big
13753       ;;
13754     powerpc64)
13755       VAR_CPU=ppc64
13756       VAR_CPU_ARCH=ppc
13757       VAR_CPU_BITS=64
13758       VAR_CPU_ENDIAN=big
13759       ;;
13760     powerpc64le)
13761       VAR_CPU=ppc64
13762       VAR_CPU_ARCH=ppc
13763       VAR_CPU_BITS=64
13764       VAR_CPU_ENDIAN=little
13765       ;;
13766     s390)
13767       VAR_CPU=s390
13768       VAR_CPU_ARCH=s390
13769       VAR_CPU_BITS=32
13770       VAR_CPU_ENDIAN=big
13771       ;;
13772     s390x)
13773       VAR_CPU=s390x
13774       VAR_CPU_ARCH=s390
13775       VAR_CPU_BITS=64
13776       VAR_CPU_ENDIAN=big
13777       ;;
13778     sparc)
13779       VAR_CPU=sparc
13780       VAR_CPU_ARCH=sparc
13781       VAR_CPU_BITS=32
13782       VAR_CPU_ENDIAN=big
13783       ;;
13784     sparcv9|sparc64)
13785       VAR_CPU=sparcv9
13786       VAR_CPU_ARCH=sparc
13787       VAR_CPU_BITS=64
13788       VAR_CPU_ENDIAN=big
13789       ;;
13790     *)
13791       as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
13792       ;;
13793   esac
13794 
13795   # ... and setup our own variables. (Do this explicitely to facilitate searching)
13796   OPENJDK_TARGET_OS="$VAR_OS"
13797   if test "x$VAR_OS_TYPE" != x; then
13798     OPENJDK_TARGET_OS_TYPE="$VAR_OS_TYPE"
13799   else
13800     OPENJDK_TARGET_OS_TYPE="$VAR_OS"
13801   fi
13802   if test "x$VAR_OS_ENV" != x; then
13803     OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
13804   else
13805     OPENJDK_TARGET_OS_ENV="$VAR_OS"
13806   fi
13807   OPENJDK_TARGET_CPU="$VAR_CPU"
13808   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
13809   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
13810   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13811 
13812 
13813 
13814 
13815 
13816 
13817 
13818 
13819   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
13820 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
13821   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
13822 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
13823 
13824 
13825 
13826 # Check whether --with-target-bits was given.
13827 if test "${with_target_bits+set}" = set; then :
13828   withval=$with_target_bits;
13829 fi
13830 
13831 
13832   # We have three types of compiles:
13833   # native  == normal compilation, target system == build system
13834   # cross   == traditional cross compilation, target system != build system; special toolchain needed
13835   # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
13836   #
13837   if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
13838     # We're doing a proper cross-compilation
13839     COMPILE_TYPE="cross"
13840   else
13841     COMPILE_TYPE="native"
13842   fi
13843 
13844   if test "x$with_target_bits" != x; then
13845     if test "x$COMPILE_TYPE" = "xcross"; then
13846       as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
13847     fi
13848 
13849     if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13850       # A reduced build is requested
13851       COMPILE_TYPE="reduced"
13852       OPENJDK_TARGET_CPU_BITS=32
13853       if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
13854         OPENJDK_TARGET_CPU=x86
13855       elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
13856         OPENJDK_TARGET_CPU=sparc
13857       else
13858         as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
13859       fi
13860     elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
13861       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
13862     elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
13863       { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
13864 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
13865     else
13866       as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
13867     fi
13868   fi
13869 
13870 
13871   { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
13872 $as_echo_n "checking compilation type... " >&6; }
13873   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
13874 $as_echo "$COMPILE_TYPE" >&6; }
13875 
13876 
13877   if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
13878     REQUIRED_OS_NAME=SunOS
13879     REQUIRED_OS_VERSION=5.10
13880   fi
13881   if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
13882     REQUIRED_OS_NAME=Linux
13883     REQUIRED_OS_VERSION=2.6
13884   fi
13885   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
13886     REQUIRED_OS_NAME=Windows
13887     if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
13888       REQUIRED_OS_VERSION=5.2
13889     else
13890       REQUIRED_OS_VERSION=5.1
13891     fi
13892   fi
13893   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
13894     REQUIRED_OS_NAME=Darwin
13895     REQUIRED_OS_VERSION=11.2
13896   fi
13897 
13898 
13899 
13900 
13901 
13902   # Also store the legacy naming of the cpu.
13903   # Ie i586 and amd64 instead of x86 and x86_64
13904   OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
13905   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13906     OPENJDK_TARGET_CPU_LEGACY="i586"
13907   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13908     # On all platforms except MacOSX replace x86_64 with amd64.
13909     OPENJDK_TARGET_CPU_LEGACY="amd64"
13910   fi
13911 
13912 
13913   # And the second legacy naming of the cpu.
13914   # Ie i386 and amd64 instead of x86 and x86_64.
13915   OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
13916   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13917     OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
13918   elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13919     OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
13920   fi
13921 
13922 
13923   # This is the name of the cpu (but using i386 and amd64 instead of
13924   # x86 and x86_64, respectively), preceeded by a /, to be used when
13925   # locating libraries. On macosx, it's empty, though.
13926   OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
13927   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13928     OPENJDK_TARGET_CPU_LIBDIR=""
13929   fi
13930 
13931 
13932   # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
13933   # /amd64 or /sparcv9. This string is appended to some library paths, like this:
13934   # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
13935   OPENJDK_TARGET_CPU_ISADIR=""
13936   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13937     if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13938       OPENJDK_TARGET_CPU_ISADIR="/amd64"
13939     elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
13940       OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
13941     fi
13942   fi
13943 
13944 
13945   # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
13946   OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
13947   if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
13948     # On linux only, we replace x86 with i386.
13949     OPENJDK_TARGET_CPU_OSARCH="i386"
13950   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13951     # On all platforms except macosx, we replace x86_64 with amd64.
13952     OPENJDK_TARGET_CPU_OSARCH="amd64"
13953   fi
13954 
13955 
13956   OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
13957   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13958     OPENJDK_TARGET_CPU_JLI="i386"
13959   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13960     # On all platforms except macosx, we replace x86_64 with amd64.
13961     OPENJDK_TARGET_CPU_JLI="amd64"
13962   fi
13963   # Now setup the -D flags for building libjli.
13964   OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
13965   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13966     if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
13967       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
13968     elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
13969       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
13970     fi
13971   fi
13972 
13973 
13974   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13975       OPENJDK_TARGET_OS_EXPORT_DIR=macosx
13976   else
13977       OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_TYPE}
13978   fi
13979 
13980 
13981   if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13982     A_LP64="LP64:="
13983     # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
13984     # unpack200.exe
13985     if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
13986       ADD_LP64="-D_LP64=1"
13987     fi
13988   fi
13989   LP64=$A_LP64
13990 
13991 
13992   if test "x$COMPILE_TYPE" = "xcross"; then
13993     # FIXME: ... or should this include reduced builds..?
13994     DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
13995   else
13996     DEFINE_CROSS_COMPILE_ARCH=""
13997   fi
13998 
13999 
14000   # ZERO_ARCHDEF is used to enable architecture-specific code
14001   case "${OPENJDK_TARGET_CPU}" in
14002     ppc)     ZERO_ARCHDEF=PPC32 ;;
14003     ppc64)   ZERO_ARCHDEF=PPC64 ;;
14004     s390*)   ZERO_ARCHDEF=S390  ;;
14005     sparc*)  ZERO_ARCHDEF=SPARC ;;
14006     x86_64*) ZERO_ARCHDEF=AMD64 ;;
14007     x86)     ZERO_ARCHDEF=IA32  ;;
14008     *)      ZERO_ARCHDEF=$(echo "${OPENJDK_TARGET_CPU_LEGACY_LIB}" | tr a-z A-Z)
14009   esac
14010 
14011 
14012 
14013 
14014 # Continue setting up basic stuff. Most remaining code require fundamental tools.
14015 
14016   # Save the current directory this script was started from
14017   CURDIR="$PWD"
14018 
14019   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
14020     PATH_SEP=";"
14021 
14022   SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
14023   if test $SRC_ROOT_LENGTH -gt 100; then
14024     as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
14025   fi
14026 
14027   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14028     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
14029 $as_echo_n "checking cygwin release... " >&6; }
14030     CYGWIN_VERSION=`$UNAME -r`
14031     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
14032 $as_echo "$CYGWIN_VERSION" >&6; }
14033     WINDOWS_ENV_VENDOR='cygwin'
14034     WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
14035 
14036     CYGWIN_VERSION_OK=`$ECHO $CYGWIN_VERSION | $GREP ^1.7.`
14037     if test "x$CYGWIN_VERSION_OK" = x; then
14038       { $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
14039 $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;}
14040       as_fn_error $? "Cannot continue" "$LINENO" 5
14041     fi
14042     if test "x$CYGPATH" = x; then
14043       as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
14044     fi
14045     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
14046 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
14047     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
14048     cygwin_winpath_root=`cd / ; cmd /c cd | grep ".*"`
14049     # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
14050     CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
14051     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
14052 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
14053     WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
14054     test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
14055     if test "x$test_cygdrive_prefix" = x; then
14056       as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
14057     fi
14058   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14059     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
14060 $as_echo_n "checking msys release... " >&6; }
14061     MSYS_VERSION=`$UNAME -r`
14062     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
14063 $as_echo "$MSYS_VERSION" >&6; }
14064 
14065     WINDOWS_ENV_VENDOR='msys'
14066     WINDOWS_ENV_VERSION="$MSYS_VERSION"
14067 
14068     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
14069 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
14070     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
14071     MSYS_ROOT_PATH=`cd / ; cmd /c cd | grep ".*"`
14072 
14073   windows_path="$MSYS_ROOT_PATH"
14074   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14075     unix_path=`$CYGPATH -u "$windows_path"`
14076     MSYS_ROOT_PATH="$unix_path"
14077   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14078     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14079     MSYS_ROOT_PATH="$unix_path"
14080   fi
14081 
14082     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
14083 $as_echo "$MSYS_ROOT_PATH" >&6; }
14084     WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
14085   else
14086     as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
14087   fi
14088 
14089   # Test if windows or unix (cygwin/msys) find is first in path.
14090   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
14091 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
14092   FIND_BINARY_OUTPUT=`find --version 2>&1`
14093   if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
14094     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
14095 $as_echo "unix style" >&6; }
14096   elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
14097     { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
14098 $as_echo "Windows" >&6; }
14099     { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
14100 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
14101     { $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
14102 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
14103     as_fn_error $? "Cannot continue" "$LINENO" 5
14104   else
14105     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
14106 $as_echo "unknown" >&6; }
14107     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
14108 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
14109   fi
14110 
14111   else
14112     PATH_SEP=":"
14113   fi
14114 
14115 
14116   # We get the top-level directory from the supporting wrappers.
14117   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
14118 $as_echo_n "checking for top-level directory... " >&6; }
14119   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
14120 $as_echo "$TOPDIR" >&6; }
14121 
14122 
14123   # We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
14124 
14125   # Only process if variable expands to non-empty
14126 
14127   if test "x$CURDIR" != x; then
14128     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14129 
14130   # Input might be given as Windows format, start by converting to
14131   # unix format.
14132   path="$CURDIR"
14133   new_path=`$CYGPATH -u "$path"`
14134 
14135   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14136   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14137   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14138   # "foo.exe" is OK but "foo" is an error.
14139   #
14140   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14141   # It is also a way to make sure we got the proper file name for the real test later on.
14142   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14143   if test "x$test_shortpath" = x; then
14144     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14145 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14146     as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
14147   fi
14148 
14149   # Call helper function which possibly converts this using DOS-style short mode.
14150   # If so, the updated path is stored in $new_path.
14151 
14152   input_path="$new_path"
14153   # Check if we need to convert this using DOS-style short mode. If the path
14154   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14155   # take no chances and rewrite it.
14156   # Note: m4 eats our [], so we need to use [ and ] instead.
14157   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14158   if test "x$has_forbidden_chars" != x; then
14159     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14160     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14161     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14162     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14163       # Going to short mode and back again did indeed matter. Since short mode is
14164       # case insensitive, let's make it lowercase to improve readability.
14165       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14166       # Now convert it back to Unix-stile (cygpath)
14167       input_path=`$CYGPATH -u "$shortmode_path"`
14168       new_path="$input_path"
14169     fi
14170   fi
14171 
14172   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14173   if test "x$test_cygdrive_prefix" = x; then
14174     # As a simple fix, exclude /usr/bin since it's not a real path.
14175     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14176       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14177       # a path prefixed by /cygdrive for fixpath to work.
14178       new_path="$CYGWIN_ROOT_PATH$input_path"
14179     fi
14180   fi
14181 
14182 
14183   if test "x$path" != "x$new_path"; then
14184     CURDIR="$new_path"
14185     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14186 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14187   fi
14188 
14189     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14190 
14191   path="$CURDIR"
14192   has_colon=`$ECHO $path | $GREP ^.:`
14193   new_path="$path"
14194   if test "x$has_colon" = x; then
14195     # Not in mixed or Windows style, start by that.
14196     new_path=`cmd //c echo $path`
14197   fi
14198 
14199 
14200   input_path="$new_path"
14201   # Check if we need to convert this using DOS-style short mode. If the path
14202   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14203   # take no chances and rewrite it.
14204   # Note: m4 eats our [], so we need to use [ and ] instead.
14205   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14206   if test "x$has_forbidden_chars" != x; then
14207     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14208     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14209   fi
14210 
14211 
14212   windows_path="$new_path"
14213   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14214     unix_path=`$CYGPATH -u "$windows_path"`
14215     new_path="$unix_path"
14216   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14217     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14218     new_path="$unix_path"
14219   fi
14220 
14221   if test "x$path" != "x$new_path"; then
14222     CURDIR="$new_path"
14223     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14224 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14225   fi
14226 
14227   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14228   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14229 
14230     else
14231       # We're on a unix platform. Hooray! :)
14232       path="$CURDIR"
14233       has_space=`$ECHO "$path" | $GREP " "`
14234       if test "x$has_space" != x; then
14235         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14236 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14237         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14238       fi
14239 
14240       # Use eval to expand a potential ~
14241       eval path="$path"
14242       if test ! -f "$path" && test ! -d "$path"; then
14243         as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14244       fi
14245 
14246       CURDIR="`cd "$path"; $THEPWDCMD -L`"
14247     fi
14248   fi
14249 
14250 
14251   # Only process if variable expands to non-empty
14252 
14253   if test "x$TOPDIR" != x; then
14254     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14255 
14256   # Input might be given as Windows format, start by converting to
14257   # unix format.
14258   path="$TOPDIR"
14259   new_path=`$CYGPATH -u "$path"`
14260 
14261   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14262   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14263   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14264   # "foo.exe" is OK but "foo" is an error.
14265   #
14266   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14267   # It is also a way to make sure we got the proper file name for the real test later on.
14268   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14269   if test "x$test_shortpath" = x; then
14270     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14271 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14272     as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
14273   fi
14274 
14275   # Call helper function which possibly converts this using DOS-style short mode.
14276   # If so, the updated path is stored in $new_path.
14277 
14278   input_path="$new_path"
14279   # Check if we need to convert this using DOS-style short mode. If the path
14280   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14281   # take no chances and rewrite it.
14282   # Note: m4 eats our [], so we need to use [ and ] instead.
14283   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14284   if test "x$has_forbidden_chars" != x; then
14285     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14286     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14287     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14288     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14289       # Going to short mode and back again did indeed matter. Since short mode is
14290       # case insensitive, let's make it lowercase to improve readability.
14291       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14292       # Now convert it back to Unix-stile (cygpath)
14293       input_path=`$CYGPATH -u "$shortmode_path"`
14294       new_path="$input_path"
14295     fi
14296   fi
14297 
14298   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14299   if test "x$test_cygdrive_prefix" = x; then
14300     # As a simple fix, exclude /usr/bin since it's not a real path.
14301     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14302       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14303       # a path prefixed by /cygdrive for fixpath to work.
14304       new_path="$CYGWIN_ROOT_PATH$input_path"
14305     fi
14306   fi
14307 
14308 
14309   if test "x$path" != "x$new_path"; then
14310     TOPDIR="$new_path"
14311     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14312 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14313   fi
14314 
14315     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14316 
14317   path="$TOPDIR"
14318   has_colon=`$ECHO $path | $GREP ^.:`
14319   new_path="$path"
14320   if test "x$has_colon" = x; then
14321     # Not in mixed or Windows style, start by that.
14322     new_path=`cmd //c echo $path`
14323   fi
14324 
14325 
14326   input_path="$new_path"
14327   # Check if we need to convert this using DOS-style short mode. If the path
14328   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14329   # take no chances and rewrite it.
14330   # Note: m4 eats our [], so we need to use [ and ] instead.
14331   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14332   if test "x$has_forbidden_chars" != x; then
14333     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14334     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14335   fi
14336 
14337 
14338   windows_path="$new_path"
14339   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14340     unix_path=`$CYGPATH -u "$windows_path"`
14341     new_path="$unix_path"
14342   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14343     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14344     new_path="$unix_path"
14345   fi
14346 
14347   if test "x$path" != "x$new_path"; then
14348     TOPDIR="$new_path"
14349     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14350 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14351   fi
14352 
14353   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14354   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14355 
14356     else
14357       # We're on a unix platform. Hooray! :)
14358       path="$TOPDIR"
14359       has_space=`$ECHO "$path" | $GREP " "`
14360       if test "x$has_space" != x; then
14361         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14362 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14363         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14364       fi
14365 
14366       # Use eval to expand a potential ~
14367       eval path="$path"
14368       if test ! -f "$path" && test ! -d "$path"; then
14369         as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14370       fi
14371 
14372       TOPDIR="`cd "$path"; $THEPWDCMD -L`"
14373     fi
14374   fi
14375 
14376   # SRC_ROOT is a traditional alias for TOPDIR.
14377   SRC_ROOT=$TOPDIR
14378 
14379   # Locate the directory of this script.
14380   AUTOCONF_DIR=$TOPDIR/common/autoconf
14381 
14382 
14383   # Setup default logging of stdout and stderr to build.log in the output root.
14384   BUILD_LOG='$(OUTPUT_ROOT)/build.log'
14385   BUILD_LOG_PREVIOUS='$(OUTPUT_ROOT)/build.log.old'
14386   BUILD_LOG_WRAPPER='$(BASH) $(SRC_ROOT)/common/bin/logger.sh $(BUILD_LOG)'
14387 
14388 
14389 
14390 
14391 
14392 # Check if it's a pure open build or if custom sources are to be used.
14393 
14394   # Check whether --enable-openjdk-only was given.
14395 if test "${enable_openjdk_only+set}" = set; then :
14396   enableval=$enable_openjdk_only;
14397 else
14398   enable_openjdk_only="no"
14399 fi
14400 
14401 
14402   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
14403 $as_echo_n "checking for presence of closed sources... " >&6; }
14404   if test -d "$SRC_ROOT/jdk/src/closed"; then
14405     CLOSED_SOURCE_PRESENT=yes
14406   else
14407     CLOSED_SOURCE_PRESENT=no
14408   fi
14409   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
14410 $as_echo "$CLOSED_SOURCE_PRESENT" >&6; }
14411 
14412   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
14413 $as_echo_n "checking if closed source is suppressed (openjdk-only)... " >&6; }
14414   SUPPRESS_CLOSED_SOURCE="$enable_openjdk_only"
14415   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
14416 $as_echo "$SUPPRESS_CLOSED_SOURCE" >&6; }
14417 
14418   if test "x$CLOSED_SOURCE_PRESENT" = xno; then
14419     OPENJDK=true
14420     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14421       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
14422 $as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
14423     fi
14424   else
14425     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14426       OPENJDK=true
14427     else
14428       OPENJDK=false
14429     fi
14430   fi
14431 
14432   if test "x$OPENJDK" = "xtrue"; then
14433     SET_OPENJDK="OPENJDK=true"
14434   fi
14435 
14436 
14437 
14438   # custom-make-dir is deprecated. Please use your custom-hook.m4 to override
14439   # the IncludeCustomExtension macro.
14440 
14441 
14442 # Check whether --with-custom-make-dir was given.
14443 if test "${with_custom_make_dir+set}" = set; then :
14444   withval=$with_custom_make_dir; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&5
14445 $as_echo "$as_me: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&2;}
14446 fi
14447 
14448 
14449 
14450 
14451 # These are needed to be able to create a configuration name (and thus the output directory)
14452 
14453   ###############################################################################
14454   #
14455   # Check which variant of the JDK that we want to build.
14456   # Currently we have:
14457   #    normal:   standard edition
14458   # but the custom make system may add other variants
14459   #
14460   # Effectively the JDK variant gives a name to a specific set of
14461   # modules to compile into the JDK. In the future, these modules
14462   # might even be Jigsaw modules.
14463   #
14464   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
14465 $as_echo_n "checking which variant of the JDK to build... " >&6; }
14466 
14467 # Check whether --with-jdk-variant was given.
14468 if test "${with_jdk_variant+set}" = set; then :
14469   withval=$with_jdk_variant;
14470 fi
14471 
14472 
14473   if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
14474     JDK_VARIANT="normal"
14475   else
14476     as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
14477   fi
14478 
14479 
14480 
14481   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
14482 $as_echo "$JDK_VARIANT" >&6; }
14483 
14484 
14485 ###############################################################################
14486 #
14487 # Check which interpreter of the JVM we want to build.
14488 # Currently we have:
14489 #    template: Template interpreter (the default)
14490 #    cpp     : C++ interpreter
14491 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which interpreter of the JVM to build" >&5
14492 $as_echo_n "checking which interpreter of the JVM to build... " >&6; }
14493 
14494 # Check whether --with-jvm-interpreter was given.
14495 if test "${with_jvm_interpreter+set}" = set; then :
14496   withval=$with_jvm_interpreter;
14497 fi
14498 
14499 
14500 if test "x$with_jvm_interpreter" = x; then
14501      with_jvm_interpreter="template"
14502 fi
14503 
14504 JVM_INTERPRETER="$with_jvm_interpreter"
14505 
14506 if test "x$JVM_INTERPRETER" != xtemplate && test "x$JVM_INTERPRETER" != xcpp; then
14507    as_fn_error $? "The available JVM interpreters are: template, cpp" "$LINENO" 5
14508 fi
14509 
14510 
14511 
14512 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_interpreter" >&5
14513 $as_echo "$with_jvm_interpreter" >&6; }
14514 
14515 
14516 
14517   ###############################################################################
14518   #
14519   # Check which variants of the JVM that we want to build.
14520   # Currently we have:
14521   #    server: normal interpreter and a tiered C1/C2 compiler
14522   #    client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms)
14523   #    minimal1: reduced form of client with optional VM services and features stripped out
14524   #    kernel: kernel footprint JVM that passes the TCK without major performance problems,
14525   #             ie normal interpreter and C1, only the serial GC, kernel jvmti etc
14526   #    zero: no machine code interpreter, no compiler
14527   #    zeroshark: zero interpreter and shark/llvm compiler backend
14528 #    core: interpreter only, no compiler (only works on some platforms)
14529   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
14530 $as_echo_n "checking which variants of the JVM to build... " >&6; }
14531 
14532 # Check whether --with-jvm-variants was given.
14533 if test "${with_jvm_variants+set}" = set; then :
14534   withval=$with_jvm_variants;
14535 fi
14536 
14537 
14538   if test "x$with_jvm_variants" = x; then
14539     with_jvm_variants="server"
14540   fi
14541 
14542   JVM_VARIANTS=",$with_jvm_variants,"
14543   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,//'`
14544 
14545   if test "x$TEST_VARIANTS" != "x,"; then
14546      as_fn_error $? "The available JVM variants are: server, client, minimal1, kernel, zero, zeroshark, core" "$LINENO" 5
14547   fi
14548   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5
14549 $as_echo "$with_jvm_variants" >&6; }
14550 
14551   JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'`
14552   JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'`
14553   JVM_VARIANT_MINIMAL1=`$ECHO "$JVM_VARIANTS" | $SED -e '/,minimal1,/!s/.*/false/g' -e '/,minimal1,/s/.*/true/g'`
14554   JVM_VARIANT_KERNEL=`$ECHO "$JVM_VARIANTS" | $SED -e '/,kernel,/!s/.*/false/g' -e '/,kernel,/s/.*/true/g'`
14555   JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'`
14556   JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'`
14557   JVM_VARIANT_CORE=`$ECHO "$JVM_VARIANTS" | $SED -e '/,core,/!s/.*/false/g' -e '/,core,/s/.*/true/g'`
14558 
14559   if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14560     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14561       as_fn_error $? "You cannot build a client JVM for a 64-bit machine." "$LINENO" 5
14562     fi
14563   fi
14564   if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14565     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14566       as_fn_error $? "You cannot build a kernel JVM for a 64-bit machine." "$LINENO" 5
14567     fi
14568   fi
14569   if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14570     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14571       as_fn_error $? "You cannot build a minimal JVM for a 64-bit machine." "$LINENO" 5
14572     fi
14573   fi
14574 
14575   # Replace the commas with AND for use in the build directory name.
14576   ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/g'`
14577   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/'`
14578   if test "x$COUNT_VARIANTS" != "x,1"; then
14579     BUILDING_MULTIPLE_JVM_VARIANTS=yes
14580   else
14581     BUILDING_MULTIPLE_JVM_VARIANTS=no
14582   fi
14583 
14584 
14585 
14586 
14587 
14588 
14589 
14590 
14591 
14592 
14593   INCLUDE_SA=true
14594   if test "x$JVM_VARIANT_ZERO" = xtrue ; then
14595     INCLUDE_SA=false
14596   fi
14597   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue ; then
14598     INCLUDE_SA=false
14599   fi
14600   if test "x$OPENJDK_TARGET_OS" = xaix ; then
14601     INCLUDE_SA=false
14602   fi
14603   if test "x$OPENJDK_TARGET_CPU" = xaarch64; then
14604     INCLUDE_SA=false
14605   fi
14606 
14607 
14608   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
14609     MACOSX_UNIVERSAL="true"
14610   fi
14611 
14612 
14613 
14614 
14615   ###############################################################################
14616   #
14617   # Set the debug level
14618   #    release: no debug information, all optimizations, no asserts.
14619   #    optimized: no debug information, all optimizations, no asserts, HotSpot target is 'optimized'.
14620   #    fastdebug: debug information (-g), all optimizations, all asserts
14621   #    slowdebug: debug information (-g), no optimizations, all asserts
14622   #
14623   DEBUG_LEVEL="release"
14624   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
14625 $as_echo_n "checking which debug level to use... " >&6; }
14626   # Check whether --enable-debug was given.
14627 if test "${enable_debug+set}" = set; then :
14628   enableval=$enable_debug;
14629         ENABLE_DEBUG="${enableval}"
14630         DEBUG_LEVEL="fastdebug"
14631 
14632 else
14633   ENABLE_DEBUG="no"
14634 fi
14635 
14636 
14637 
14638 # Check whether --with-debug-level was given.
14639 if test "${with_debug_level+set}" = set; then :
14640   withval=$with_debug_level;
14641         DEBUG_LEVEL="${withval}"
14642         if test "x$ENABLE_DEBUG" = xyes; then
14643           as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
14644         fi
14645 
14646 fi
14647 
14648   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
14649 $as_echo "$DEBUG_LEVEL" >&6; }
14650 
14651   if test "x$DEBUG_LEVEL" != xrelease && \
14652       test "x$DEBUG_LEVEL" != xoptimized && \
14653       test "x$DEBUG_LEVEL" != xfastdebug && \
14654       test "x$DEBUG_LEVEL" != xslowdebug; then
14655     as_fn_error $? "Allowed debug levels are: release, fastdebug and slowdebug" "$LINENO" 5
14656   fi
14657 
14658 
14659   ###############################################################################
14660   #
14661   # Setup legacy vars/targets and new vars to deal with different debug levels.
14662   #
14663 
14664   case $DEBUG_LEVEL in
14665     release )
14666       VARIANT="OPT"
14667       FASTDEBUG="false"
14668       DEBUG_CLASSFILES="false"
14669       BUILD_VARIANT_RELEASE=""
14670       HOTSPOT_DEBUG_LEVEL="product"
14671       HOTSPOT_EXPORT="product"
14672       ;;
14673     fastdebug )
14674       VARIANT="DBG"
14675       FASTDEBUG="true"
14676       DEBUG_CLASSFILES="true"
14677       BUILD_VARIANT_RELEASE="-fastdebug"
14678       HOTSPOT_DEBUG_LEVEL="fastdebug"
14679       HOTSPOT_EXPORT="fastdebug"
14680       ;;
14681     slowdebug )
14682       VARIANT="DBG"
14683       FASTDEBUG="false"
14684       DEBUG_CLASSFILES="true"
14685       BUILD_VARIANT_RELEASE="-debug"
14686       HOTSPOT_DEBUG_LEVEL="debug"
14687       HOTSPOT_EXPORT="debug"
14688       ;;
14689     optimized )
14690       VARIANT="OPT"
14691       FASTDEBUG="false"
14692       DEBUG_CLASSFILES="false"
14693       BUILD_VARIANT_RELEASE="-optimized"
14694       HOTSPOT_DEBUG_LEVEL="optimized"
14695       HOTSPOT_EXPORT="optimized"
14696       ;;
14697   esac
14698 
14699   # The debug level 'optimized' is a little special because it is currently only
14700   # applicable to the HotSpot build where it means to build a completely
14701   # optimized version of the VM without any debugging code (like for the
14702   # 'release' debug level which is called 'product' in the HotSpot build) but
14703   # with the exception that it can contain additional code which is otherwise
14704   # protected by '#ifndef PRODUCT' macros. These 'optimized' builds are used to
14705   # test new and/or experimental features which are not intended for customer
14706   # shipment. Because these new features need to be tested and benchmarked in
14707   # real world scenarios, we want to build the containing JDK at the 'release'
14708   # debug level.
14709   if test "x$DEBUG_LEVEL" = xoptimized; then
14710     DEBUG_LEVEL="release"
14711   fi
14712 
14713   #####
14714   # Generate the legacy makefile targets for hotspot.
14715   # The hotspot api for selecting the build artifacts, really, needs to be improved.
14716   # JDK-7195896 will fix this on the hotspot side by using the JVM_VARIANT_* variables to
14717   # determine what needs to be built. All we will need to set here is all_product, all_fastdebug etc
14718   # But until then ...
14719   HOTSPOT_TARGET=""
14720 
14721   if test "x$JVM_VARIANT_SERVER" = xtrue; then
14722     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL} "
14723   fi
14724 
14725   if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14726     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}1 "
14727   fi
14728 
14729   if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14730     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}minimal1 "
14731   fi
14732 
14733   if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14734     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}kernel "
14735   fi
14736 
14737   if test "x$JVM_VARIANT_ZERO" = xtrue; then
14738     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}zero "
14739   fi
14740 
14741   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
14742     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}shark "
14743   fi
14744 
14745   if test "x$JVM_VARIANT_CORE" = xtrue; then
14746     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}core "
14747   fi
14748 
14749   HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT"
14750 
14751   # On Macosx universal binaries are produced, but they only contain
14752   # 64 bit intel. This invalidates control of which jvms are built
14753   # from configure, but only server is valid anyway. Fix this
14754   # when hotspot makefiles are rewritten.
14755   if test "x$MACOSX_UNIVERSAL" = xtrue; then
14756     HOTSPOT_TARGET=universal_${HOTSPOT_EXPORT}
14757   fi
14758 
14759   #####
14760 
14761 
14762 
14763 
14764 
14765 
14766 
14767 
14768 # With basic setup done, call the custom early hook.
14769 
14770 
14771 # Check if we have devkits, extra paths or sysroot set.
14772 
14773 
14774 # Check whether --with-devkit was given.
14775 if test "${with_devkit+set}" = set; then :
14776   withval=$with_devkit;
14777 
14778   # Only process if variable expands to non-empty
14779 
14780   if test "x$with_devkit" != x; then
14781     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14782 
14783   # Input might be given as Windows format, start by converting to
14784   # unix format.
14785   path="$with_devkit"
14786   new_path=`$CYGPATH -u "$path"`
14787 
14788   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14789   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14790   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14791   # "foo.exe" is OK but "foo" is an error.
14792   #
14793   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14794   # It is also a way to make sure we got the proper file name for the real test later on.
14795   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14796   if test "x$test_shortpath" = x; then
14797     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14798 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14799     as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
14800   fi
14801 
14802   # Call helper function which possibly converts this using DOS-style short mode.
14803   # If so, the updated path is stored in $new_path.
14804 
14805   input_path="$new_path"
14806   # Check if we need to convert this using DOS-style short mode. If the path
14807   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14808   # take no chances and rewrite it.
14809   # Note: m4 eats our [], so we need to use [ and ] instead.
14810   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14811   if test "x$has_forbidden_chars" != x; then
14812     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14813     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14814     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14815     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14816       # Going to short mode and back again did indeed matter. Since short mode is
14817       # case insensitive, let's make it lowercase to improve readability.
14818       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14819       # Now convert it back to Unix-stile (cygpath)
14820       input_path=`$CYGPATH -u "$shortmode_path"`
14821       new_path="$input_path"
14822     fi
14823   fi
14824 
14825   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14826   if test "x$test_cygdrive_prefix" = x; then
14827     # As a simple fix, exclude /usr/bin since it's not a real path.
14828     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14829       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14830       # a path prefixed by /cygdrive for fixpath to work.
14831       new_path="$CYGWIN_ROOT_PATH$input_path"
14832     fi
14833   fi
14834 
14835 
14836   if test "x$path" != "x$new_path"; then
14837     with_devkit="$new_path"
14838     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14839 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14840   fi
14841 
14842     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14843 
14844   path="$with_devkit"
14845   has_colon=`$ECHO $path | $GREP ^.:`
14846   new_path="$path"
14847   if test "x$has_colon" = x; then
14848     # Not in mixed or Windows style, start by that.
14849     new_path=`cmd //c echo $path`
14850   fi
14851 
14852 
14853   input_path="$new_path"
14854   # Check if we need to convert this using DOS-style short mode. If the path
14855   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14856   # take no chances and rewrite it.
14857   # Note: m4 eats our [], so we need to use [ and ] instead.
14858   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14859   if test "x$has_forbidden_chars" != x; then
14860     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14861     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14862   fi
14863 
14864 
14865   windows_path="$new_path"
14866   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14867     unix_path=`$CYGPATH -u "$windows_path"`
14868     new_path="$unix_path"
14869   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14870     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14871     new_path="$unix_path"
14872   fi
14873 
14874   if test "x$path" != "x$new_path"; then
14875     with_devkit="$new_path"
14876     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14877 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14878   fi
14879 
14880   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14881   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14882 
14883     else
14884       # We're on a unix platform. Hooray! :)
14885       path="$with_devkit"
14886       has_space=`$ECHO "$path" | $GREP " "`
14887       if test "x$has_space" != x; then
14888         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14889 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14890         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14891       fi
14892 
14893       # Use eval to expand a potential ~
14894       eval path="$path"
14895       if test ! -f "$path" && test ! -d "$path"; then
14896         as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
14897       fi
14898 
14899       with_devkit="`cd "$path"; $THEPWDCMD -L`"
14900     fi
14901   fi
14902 
14903         DEVKIT_ROOT="$with_devkit"
14904         # Check for a meta data info file in the root of the devkit
14905         if test -f "$DEVKIT_ROOT/devkit.info"; then
14906           # This potentially sets the following:
14907           # DEVKIT_NAME: A descriptive name of the devkit
14908           # DEVKIT_TOOLCHAIN_PATH: Corresponds to --with-toolchain-path
14909           # DEVKIT_EXTRA_PATH: Corresponds to --with-extra-path
14910           # DEVKIT_SYSROOT: Corresponds to --with-sysroot
14911           . $DEVKIT_ROOT/devkit.info
14912         fi
14913 
14914         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
14915 $as_echo_n "checking for devkit... " >&6; }
14916         if test "x$DEVKIT_NAME" != x; then
14917           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
14918 $as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
14919         else
14920           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
14921 $as_echo "$DEVKIT_ROOT" >&6; }
14922         fi
14923 
14924         if test "x$DEVKIT_EXTRA_PATH" != x; then
14925 
14926   if test "x$DEVKIT_EXTRA_PATH" != x; then
14927     if test "x$EXTRA_PATH" = x; then
14928       EXTRA_PATH="$DEVKIT_EXTRA_PATH"
14929     else
14930       EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH"
14931     fi
14932   fi
14933 
14934         fi
14935 
14936         # Fallback default of just /bin if DEVKIT_PATH is not defined
14937         if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
14938           DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin"
14939         fi
14940 
14941   if test "x$DEVKIT_TOOLCHAIN_PATH" != x; then
14942     if test "x$TOOLCHAIN_PATH" = x; then
14943       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH"
14944     else
14945       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH:$TOOLCHAIN_PATH"
14946     fi
14947   fi
14948 
14949 
14950         # If DEVKIT_SYSROOT is set, use that, otherwise try a couple of known
14951         # places for backwards compatiblity.
14952         if test "x$DEVKIT_SYSROOT" != x; then
14953           SYSROOT="$DEVKIT_SYSROOT"
14954         elif test -d "$DEVKIT_ROOT/$host_alias/libc"; then
14955           SYSROOT="$DEVKIT_ROOT/$host_alias/libc"
14956         elif test -d "$DEVKIT_ROOT/$host/sys-root"; then
14957           SYSROOT="$DEVKIT_ROOT/$host/sys-root"
14958         fi
14959 
14960 
14961 fi
14962 
14963 
14964   # You can force the sysroot if the sysroot encoded into the compiler tools
14965   # is not correct.
14966 
14967 # Check whether --with-sys-root was given.
14968 if test "${with_sys_root+set}" = set; then :
14969   withval=$with_sys_root; SYSROOT=$with_sys_root
14970 
14971 fi
14972 
14973 
14974 
14975 # Check whether --with-sysroot was given.
14976 if test "${with_sysroot+set}" = set; then :
14977   withval=$with_sysroot; SYSROOT=$with_sysroot
14978 
14979 fi
14980 
14981 
14982 
14983 # Check whether --with-tools-dir was given.
14984 if test "${with_tools_dir+set}" = set; then :
14985   withval=$with_tools_dir;
14986   if test "x$with_tools_dir" != x; then
14987     if test "x$TOOLCHAIN_PATH" = x; then
14988       TOOLCHAIN_PATH="$with_tools_dir"
14989     else
14990       TOOLCHAIN_PATH="$with_tools_dir:$TOOLCHAIN_PATH"
14991     fi
14992   fi
14993 
14994 
14995 fi
14996 
14997 
14998 
14999 # Check whether --with-toolchain-path was given.
15000 if test "${with_toolchain_path+set}" = set; then :
15001   withval=$with_toolchain_path;
15002   if test "x$with_toolchain_path" != x; then
15003     if test "x$TOOLCHAIN_PATH" = x; then
15004       TOOLCHAIN_PATH="$with_toolchain_path"
15005     else
15006       TOOLCHAIN_PATH="$with_toolchain_path:$TOOLCHAIN_PATH"
15007     fi
15008   fi
15009 
15010 
15011 fi
15012 
15013 
15014 
15015 # Check whether --with-extra-path was given.
15016 if test "${with_extra_path+set}" = set; then :
15017   withval=$with_extra_path;
15018   if test "x$with_extra_path" != x; then
15019     if test "x$EXTRA_PATH" = x; then
15020       EXTRA_PATH="$with_extra_path"
15021     else
15022       EXTRA_PATH="$with_extra_path:$EXTRA_PATH"
15023     fi
15024   fi
15025 
15026 
15027 fi
15028 
15029 
15030   if test "x$OPENJDK_BUILD_OS" = "xmacosx"; then
15031     # detect if Xcode is installed by running xcodebuild -version
15032     # if no Xcode installed, xcodebuild exits with 1
15033     # if Xcode is installed, even if xcode-select is misconfigured, then it exits with 0
15034     if /usr/bin/xcodebuild -version >/dev/null 2>&1; then
15035       # We need to use xcodebuild in the toolchain dir provided by the user, this will
15036       # fall back on the stub binary in /usr/bin/xcodebuild
15037       # Extract the first word of "xcodebuild", so it can be a program name with args.
15038 set dummy xcodebuild; ac_word=$2
15039 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15040 $as_echo_n "checking for $ac_word... " >&6; }
15041 if ${ac_cv_path_XCODEBUILD+:} false; then :
15042   $as_echo_n "(cached) " >&6
15043 else
15044   case $XCODEBUILD in
15045   [\\/]* | ?:[\\/]*)
15046   ac_cv_path_XCODEBUILD="$XCODEBUILD" # Let the user override the test with a path.
15047   ;;
15048   *)
15049   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15050 for as_dir in $TOOLCHAIN_PATH
15051 do
15052   IFS=$as_save_IFS
15053   test -z "$as_dir" && as_dir=.
15054     for ac_exec_ext in '' $ac_executable_extensions; do
15055   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15056     ac_cv_path_XCODEBUILD="$as_dir/$ac_word$ac_exec_ext"
15057     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15058     break 2
15059   fi
15060 done
15061   done
15062 IFS=$as_save_IFS
15063 
15064   test -z "$ac_cv_path_XCODEBUILD" && ac_cv_path_XCODEBUILD="/usr/bin/xcodebuild"
15065   ;;
15066 esac
15067 fi
15068 XCODEBUILD=$ac_cv_path_XCODEBUILD
15069 if test -n "$XCODEBUILD"; then
15070   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XCODEBUILD" >&5
15071 $as_echo "$XCODEBUILD" >&6; }
15072 else
15073   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15074 $as_echo "no" >&6; }
15075 fi
15076 
15077 
15078     else
15079       # this should result in SYSROOT being empty, unless --with-sysroot is provided
15080       # when only the command line tools are installed there are no SDKs, so headers
15081       # are copied into the system frameworks
15082       XCODEBUILD=
15083 
15084     fi
15085 
15086     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sdk name" >&5
15087 $as_echo_n "checking for sdk name... " >&6; }
15088 
15089 # Check whether --with-sdk-name was given.
15090 if test "${with_sdk_name+set}" = set; then :
15091   withval=$with_sdk_name; SDKNAME=$with_sdk_name
15092 
15093 fi
15094 
15095     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDKNAME" >&5
15096 $as_echo "$SDKNAME" >&6; }
15097 
15098     # if toolchain path is specified then don't rely on system headers, they may not compile
15099     HAVE_SYSTEM_FRAMEWORK_HEADERS=0
15100     test -z "$TOOLCHAIN_PATH" && \
15101       HAVE_SYSTEM_FRAMEWORK_HEADERS=`test ! -f /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h; echo $?`
15102 
15103     if test -z "$SYSROOT"; then
15104       if test -n "$XCODEBUILD"; then
15105         # if we don't have system headers, use default SDK name (last resort)
15106         if test -z "$SDKNAME" -a $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
15107           SDKNAME=${SDKNAME:-macosx}
15108         fi
15109 
15110         if test -n "$SDKNAME"; then
15111           # Call xcodebuild to determine SYSROOT
15112           SYSROOT=`"$XCODEBUILD" -sdk $SDKNAME -version | grep '^Path: ' | sed 's/Path: //'`
15113         fi
15114       else
15115         if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
15116           as_fn_error $? "No xcodebuild tool and no system framework headers found, use --with-sysroot or --with-sdk-name to provide a path to a valid SDK" "$LINENO" 5
15117         fi
15118       fi
15119     else
15120       # warn user if --with-sdk-name was also set
15121       if test -n "$with_sdk_name"; then
15122         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&5
15123 $as_echo "$as_me: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&2;}
15124       fi
15125     fi
15126 
15127     if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0 -a -z "$SYSROOT"; then
15128       # If no system framework headers, then SYSROOT must be set, or we won't build
15129       as_fn_error $? "Unable to determine SYSROOT and no headers found in /System/Library/Frameworks. Check Xcode configuration, --with-sysroot or --with-sdk-name arguments." "$LINENO" 5
15130     fi
15131 
15132     # Perform a basic sanity test
15133     if test ! -f "$SYSROOT/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h"; then
15134       if test -z "$SYSROOT"; then
15135         as_fn_error $? "Unable to find required framework headers, provide a path to an SDK via --with-sysroot or --with-sdk-name and be sure Xcode is installed properly" "$LINENO" 5
15136       else
15137         as_fn_error $? "Invalid SDK or SYSROOT path, dependent framework headers not found" "$LINENO" 5
15138       fi
15139     fi
15140 
15141     # set SDKROOT too, Xcode tools will pick it up
15142     SDKROOT=$SYSROOT
15143 
15144   fi
15145 
15146   # Prepend the extra path to the global path
15147 
15148   if test "x$EXTRA_PATH" != x; then
15149     if test "x$PATH" = x; then
15150       PATH="$EXTRA_PATH"
15151     else
15152       PATH="$EXTRA_PATH:$PATH"
15153     fi
15154   fi
15155 
15156 
15157   if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
15158     # Add extra search paths on solaris for utilities like ar and as etc...
15159     PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin"
15160   fi
15161 
15162   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
15163 $as_echo_n "checking for sysroot... " >&6; }
15164   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
15165 $as_echo "$SYSROOT" >&6; }
15166   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
15167 $as_echo_n "checking for toolchain path... " >&6; }
15168   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
15169 $as_echo "$TOOLCHAIN_PATH" >&6; }
15170   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
15171 $as_echo_n "checking for extra path... " >&6; }
15172   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
15173 $as_echo "$EXTRA_PATH" >&6; }
15174 
15175 
15176 # To properly create a configuration name, we need to have the OpenJDK target
15177 # and options (variants and debug level) parsed.
15178 
15179 
15180 
15181 # Check whether --with-conf-name was given.
15182 if test "${with_conf_name+set}" = set; then :
15183   withval=$with_conf_name;  CONF_NAME=${with_conf_name}
15184 fi
15185 
15186 
15187   # Test from where we are running configure, in or outside of src root.
15188   { $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
15189 $as_echo_n "checking where to store configuration... " >&6; }
15190   if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
15191       || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
15192       || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
15193     # We are running configure from the src root.
15194     # Create a default ./build/target-variant-debuglevel output root.
15195     if test "x${CONF_NAME}" = x; then
15196       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
15197 $as_echo "in default location" >&6; }
15198       CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}"
15199     else
15200       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
15201 $as_echo "in build directory with custom name" >&6; }
15202     fi
15203     OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
15204     $MKDIR -p "$OUTPUT_ROOT"
15205     if test ! -d "$OUTPUT_ROOT"; then
15206       as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
15207     fi
15208   else
15209     # We are running configure from outside of the src dir.
15210     # Then use the current directory as output dir!
15211     # If configuration is situated in normal build directory, just use the build
15212     # directory name as configuration name, otherwise use the complete path.
15213     if test "x${CONF_NAME}" = x; then
15214       CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
15215     fi
15216     OUTPUT_ROOT="$CURDIR"
15217     { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
15218 $as_echo "in current directory" >&6; }
15219 
15220     # WARNING: This might be a bad thing to do. You need to be sure you want to
15221     # have a configuration in this directory. Do some sanity checks!
15222 
15223     if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
15224       # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
15225       # other files
15226       files_present=`$LS $OUTPUT_ROOT`
15227       # Configure has already touched config.log and confdefs.h in the current dir when this check
15228       # is performed.
15229       filtered_files=`$ECHO "$files_present" | $SED -e 's/config.log//g' -e 's/confdefs.h//g' -e 's/ //g' \
15230       | $TR -d '\n'`
15231       if test "x$filtered_files" != x; then
15232         { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
15233 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
15234         { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
15235 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
15236         { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
15237 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
15238         { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
15239 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
15240         { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
15241 $as_echo "$as_me: seriously mess up just about everything." >&6;}
15242         { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
15243 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
15244         { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
15245 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
15246         as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
15247       fi
15248     fi
15249   fi
15250   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
15251 $as_echo_n "checking what configuration name to use... " >&6; }
15252   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
15253 $as_echo "$CONF_NAME" >&6; }
15254 
15255 
15256   # Only process if variable expands to non-empty
15257 
15258   if test "x$OUTPUT_ROOT" != x; then
15259     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15260 
15261   # Input might be given as Windows format, start by converting to
15262   # unix format.
15263   path="$OUTPUT_ROOT"
15264   new_path=`$CYGPATH -u "$path"`
15265 
15266   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15267   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15268   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15269   # "foo.exe" is OK but "foo" is an error.
15270   #
15271   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15272   # It is also a way to make sure we got the proper file name for the real test later on.
15273   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15274   if test "x$test_shortpath" = x; then
15275     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
15276 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
15277     as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
15278   fi
15279 
15280   # Call helper function which possibly converts this using DOS-style short mode.
15281   # If so, the updated path is stored in $new_path.
15282 
15283   input_path="$new_path"
15284   # Check if we need to convert this using DOS-style short mode. If the path
15285   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15286   # take no chances and rewrite it.
15287   # Note: m4 eats our [], so we need to use [ and ] instead.
15288   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15289   if test "x$has_forbidden_chars" != x; then
15290     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15291     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15292     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15293     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15294       # Going to short mode and back again did indeed matter. Since short mode is
15295       # case insensitive, let's make it lowercase to improve readability.
15296       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15297       # Now convert it back to Unix-stile (cygpath)
15298       input_path=`$CYGPATH -u "$shortmode_path"`
15299       new_path="$input_path"
15300     fi
15301   fi
15302 
15303   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15304   if test "x$test_cygdrive_prefix" = x; then
15305     # As a simple fix, exclude /usr/bin since it's not a real path.
15306     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15307       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15308       # a path prefixed by /cygdrive for fixpath to work.
15309       new_path="$CYGWIN_ROOT_PATH$input_path"
15310     fi
15311   fi
15312 
15313 
15314   if test "x$path" != "x$new_path"; then
15315     OUTPUT_ROOT="$new_path"
15316     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15317 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15318   fi
15319 
15320     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15321 
15322   path="$OUTPUT_ROOT"
15323   has_colon=`$ECHO $path | $GREP ^.:`
15324   new_path="$path"
15325   if test "x$has_colon" = x; then
15326     # Not in mixed or Windows style, start by that.
15327     new_path=`cmd //c echo $path`
15328   fi
15329 
15330 
15331   input_path="$new_path"
15332   # Check if we need to convert this using DOS-style short mode. If the path
15333   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15334   # take no chances and rewrite it.
15335   # Note: m4 eats our [], so we need to use [ and ] instead.
15336   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15337   if test "x$has_forbidden_chars" != x; then
15338     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15339     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15340   fi
15341 
15342 
15343   windows_path="$new_path"
15344   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15345     unix_path=`$CYGPATH -u "$windows_path"`
15346     new_path="$unix_path"
15347   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15348     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15349     new_path="$unix_path"
15350   fi
15351 
15352   if test "x$path" != "x$new_path"; then
15353     OUTPUT_ROOT="$new_path"
15354     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15355 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15356   fi
15357 
15358   # Save the first 10 bytes of this path to the storage, so fixpath can work.
15359   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15360 
15361     else
15362       # We're on a unix platform. Hooray! :)
15363       path="$OUTPUT_ROOT"
15364       has_space=`$ECHO "$path" | $GREP " "`
15365       if test "x$has_space" != x; then
15366         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
15367 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
15368         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15369       fi
15370 
15371       # Use eval to expand a potential ~
15372       eval path="$path"
15373       if test ! -f "$path" && test ! -d "$path"; then
15374         as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
15375       fi
15376 
15377       OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
15378     fi
15379   fi
15380 
15381 
15382   SPEC=$OUTPUT_ROOT/spec.gmk
15383 
15384   CONF_NAME=$CONF_NAME
15385 
15386   OUTPUT_ROOT=$OUTPUT_ROOT
15387 
15388 
15389   # The spec.gmk file contains all variables for the make system.
15390   ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
15391 
15392   # The hotspot-spec.gmk file contains legacy variables for the hotspot make system.
15393   ac_config_files="$ac_config_files $OUTPUT_ROOT/hotspot-spec.gmk:$AUTOCONF_DIR/hotspot-spec.gmk.in"
15394 
15395   # The bootcycle-spec.gmk file contains support for boot cycle builds.
15396   ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
15397 
15398   # The compare.sh is used to compare the build output to other builds.
15399   ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
15400 
15401   # The generated Makefile knows where the spec.gmk is and where the source is.
15402   # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
15403   # which will look for generated configurations
15404   ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
15405 
15406 
15407 
15408 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
15409 
15410   for ac_prog in apt-get yum port pkgutil pkgadd
15411 do
15412   # Extract the first word of "$ac_prog", so it can be a program name with args.
15413 set dummy $ac_prog; ac_word=$2
15414 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15415 $as_echo_n "checking for $ac_word... " >&6; }
15416 if ${ac_cv_prog_PKGHANDLER+:} false; then :
15417   $as_echo_n "(cached) " >&6
15418 else
15419   if test -n "$PKGHANDLER"; then
15420   ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
15421 else
15422 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15423 for as_dir in $PATH
15424 do
15425   IFS=$as_save_IFS
15426   test -z "$as_dir" && as_dir=.
15427     for ac_exec_ext in '' $ac_executable_extensions; do
15428   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15429     ac_cv_prog_PKGHANDLER="$ac_prog"
15430     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15431     break 2
15432   fi
15433 done
15434   done
15435 IFS=$as_save_IFS
15436 
15437 fi
15438 fi
15439 PKGHANDLER=$ac_cv_prog_PKGHANDLER
15440 if test -n "$PKGHANDLER"; then
15441   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
15442 $as_echo "$PKGHANDLER" >&6; }
15443 else
15444   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15445 $as_echo "no" >&6; }
15446 fi
15447 
15448 
15449   test -n "$PKGHANDLER" && break
15450 done
15451 
15452 
15453 
15454 # Setup tools that requires more complex handling, or that is not needed by the configure script.
15455 
15456 
15457   # We need to find a recent version of GNU make. Especially on Solaris, this can be tricky.
15458   if test "x$MAKE" != x; then
15459     # User has supplied a make, test it.
15460     if test ! -f "$MAKE"; then
15461       as_fn_error $? "The specified make (by MAKE=$MAKE) is not found." "$LINENO" 5
15462     fi
15463 
15464   MAKE_CANDIDATE=""$MAKE""
15465   DESCRIPTION="user supplied MAKE=$MAKE"
15466   if test "x$MAKE_CANDIDATE" != x; then
15467     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15468 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15469     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15470     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15471     if test "x$IS_GNU_MAKE" = x; then
15472       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15473 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15474     else
15475       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15476       if test "x$IS_MODERN_MAKE" = x; then
15477         { $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
15478 $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;}
15479       else
15480         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15481           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15482             MAKE_EXPECTED_ENV='cygwin'
15483           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15484             MAKE_EXPECTED_ENV='msys'
15485           else
15486             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15487           fi
15488           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15489           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15490         else
15491           # Not relevant for non-Windows
15492           IS_MAKE_CORRECT_ENV=true
15493         fi
15494         if test "x$IS_MAKE_CORRECT_ENV" = x; then
15495           { $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
15496 $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;}
15497         else
15498           FOUND_MAKE=$MAKE_CANDIDATE
15499 
15500   # Only process if variable expands to non-empty
15501 
15502   if test "x$FOUND_MAKE" != x; then
15503     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15504 
15505   # First separate the path from the arguments. This will split at the first
15506   # space.
15507   complete="$FOUND_MAKE"
15508   path="${complete%% *}"
15509   tmp="$complete EOL"
15510   arguments="${tmp#* }"
15511 
15512   # Input might be given as Windows format, start by converting to
15513   # unix format.
15514   new_path=`$CYGPATH -u "$path"`
15515 
15516   # Now try to locate executable using which
15517   new_path=`$WHICH "$new_path" 2> /dev/null`
15518   # bat and cmd files are not always considered executable in cygwin causing which
15519   # to not find them
15520   if test "x$new_path" = x \
15521       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15522       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15523     new_path=`$CYGPATH -u "$path"`
15524   fi
15525   if test "x$new_path" = x; then
15526     # Oops. Which didn't find the executable.
15527     # The splitting of arguments from the executable at a space might have been incorrect,
15528     # since paths with space are more likely in Windows. Give it another try with the whole
15529     # argument.
15530     path="$complete"
15531     arguments="EOL"
15532     new_path=`$CYGPATH -u "$path"`
15533     new_path=`$WHICH "$new_path" 2> /dev/null`
15534     # bat and cmd files are not always considered executable in cygwin causing which
15535     # to not find them
15536     if test "x$new_path" = x \
15537         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15538         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15539       new_path=`$CYGPATH -u "$path"`
15540     fi
15541     if test "x$new_path" = x; then
15542       # It's still not found. Now this is an unrecoverable error.
15543       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15544 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15545       has_space=`$ECHO "$complete" | $GREP " "`
15546       if test "x$has_space" != x; then
15547         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15548 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15549       fi
15550       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15551     fi
15552   fi
15553 
15554   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15555   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15556   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15557   # "foo.exe" is OK but "foo" is an error.
15558   #
15559   # This test is therefore slightly more accurate than "test -f" to check for file presence.
15560   # It is also a way to make sure we got the proper file name for the real test later on.
15561   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15562   if test "x$test_shortpath" = x; then
15563     # Short path failed, file does not exist as specified.
15564     # Try adding .exe or .cmd
15565     if test -f "${new_path}.exe"; then
15566       input_to_shortpath="${new_path}.exe"
15567     elif test -f "${new_path}.cmd"; then
15568       input_to_shortpath="${new_path}.cmd"
15569     else
15570       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15571 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15572       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15573 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15574       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15575     fi
15576   else
15577     input_to_shortpath="$new_path"
15578   fi
15579 
15580   # Call helper function which possibly converts this using DOS-style short mode.
15581   # If so, the updated path is stored in $new_path.
15582   new_path="$input_to_shortpath"
15583 
15584   input_path="$input_to_shortpath"
15585   # Check if we need to convert this using DOS-style short mode. If the path
15586   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15587   # take no chances and rewrite it.
15588   # Note: m4 eats our [], so we need to use [ and ] instead.
15589   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15590   if test "x$has_forbidden_chars" != x; then
15591     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15592     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15593     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15594     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15595       # Going to short mode and back again did indeed matter. Since short mode is
15596       # case insensitive, let's make it lowercase to improve readability.
15597       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15598       # Now convert it back to Unix-stile (cygpath)
15599       input_path=`$CYGPATH -u "$shortmode_path"`
15600       new_path="$input_path"
15601     fi
15602   fi
15603 
15604   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15605   if test "x$test_cygdrive_prefix" = x; then
15606     # As a simple fix, exclude /usr/bin since it's not a real path.
15607     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15608       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15609       # a path prefixed by /cygdrive for fixpath to work.
15610       new_path="$CYGWIN_ROOT_PATH$input_path"
15611     fi
15612   fi
15613 
15614   # remove trailing .exe if any
15615   new_path="${new_path/%.exe/}"
15616 
15617     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15618 
15619   # First separate the path from the arguments. This will split at the first
15620   # space.
15621   complete="$FOUND_MAKE"
15622   path="${complete%% *}"
15623   tmp="$complete EOL"
15624   arguments="${tmp#* }"
15625 
15626   # Input might be given as Windows format, start by converting to
15627   # unix format.
15628   new_path="$path"
15629 
15630   windows_path="$new_path"
15631   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15632     unix_path=`$CYGPATH -u "$windows_path"`
15633     new_path="$unix_path"
15634   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15635     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15636     new_path="$unix_path"
15637   fi
15638 
15639 
15640   # Now try to locate executable using which
15641   new_path=`$WHICH "$new_path" 2> /dev/null`
15642 
15643   if test "x$new_path" = x; then
15644     # Oops. Which didn't find the executable.
15645     # The splitting of arguments from the executable at a space might have been incorrect,
15646     # since paths with space are more likely in Windows. Give it another try with the whole
15647     # argument.
15648     path="$complete"
15649     arguments="EOL"
15650     new_path="$path"
15651 
15652   windows_path="$new_path"
15653   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15654     unix_path=`$CYGPATH -u "$windows_path"`
15655     new_path="$unix_path"
15656   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15657     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15658     new_path="$unix_path"
15659   fi
15660 
15661 
15662     new_path=`$WHICH "$new_path" 2> /dev/null`
15663     # bat and cmd files are not always considered executable in MSYS causing which
15664     # to not find them
15665     if test "x$new_path" = x \
15666         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15667         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15668       new_path="$path"
15669 
15670   windows_path="$new_path"
15671   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15672     unix_path=`$CYGPATH -u "$windows_path"`
15673     new_path="$unix_path"
15674   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15675     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15676     new_path="$unix_path"
15677   fi
15678 
15679     fi
15680 
15681     if test "x$new_path" = x; then
15682       # It's still not found. Now this is an unrecoverable error.
15683       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15684 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15685       has_space=`$ECHO "$complete" | $GREP " "`
15686       if test "x$has_space" != x; then
15687         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15688 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15689       fi
15690       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15691     fi
15692   fi
15693 
15694   # Now new_path has a complete unix path to the binary
15695   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15696     # Keep paths in /bin as-is, but remove trailing .exe if any
15697     new_path="${new_path/%.exe/}"
15698     # Do not save /bin paths to all_fixpath_prefixes!
15699   else
15700     # Not in mixed or Windows style, start by that.
15701     new_path=`cmd //c echo $new_path`
15702 
15703   input_path="$new_path"
15704   # Check if we need to convert this using DOS-style short mode. If the path
15705   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15706   # take no chances and rewrite it.
15707   # Note: m4 eats our [], so we need to use [ and ] instead.
15708   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15709   if test "x$has_forbidden_chars" != x; then
15710     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15711     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15712   fi
15713 
15714     # Output is in $new_path
15715 
15716   windows_path="$new_path"
15717   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15718     unix_path=`$CYGPATH -u "$windows_path"`
15719     new_path="$unix_path"
15720   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15721     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15722     new_path="$unix_path"
15723   fi
15724 
15725     # remove trailing .exe if any
15726     new_path="${new_path/%.exe/}"
15727 
15728     # Save the first 10 bytes of this path to the storage, so fixpath can work.
15729     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15730   fi
15731 
15732     else
15733       # We're on a unix platform. Hooray! :)
15734       # First separate the path from the arguments. This will split at the first
15735       # space.
15736       complete="$FOUND_MAKE"
15737       path="${complete%% *}"
15738       tmp="$complete EOL"
15739       arguments="${tmp#* }"
15740 
15741       # Cannot rely on the command "which" here since it doesn't always work.
15742       is_absolute_path=`$ECHO "$path" | $GREP ^/`
15743       if test -z "$is_absolute_path"; then
15744         # Path to executable is not absolute. Find it.
15745         IFS_save="$IFS"
15746         IFS=:
15747         for p in $PATH; do
15748           if test -f "$p/$path" && test -x "$p/$path"; then
15749             new_path="$p/$path"
15750             break
15751           fi
15752         done
15753         IFS="$IFS_save"
15754       else
15755         # This is an absolute path, we can use it without further modifications.
15756         new_path="$path"
15757       fi
15758 
15759       if test "x$new_path" = x; then
15760         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15761 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15762         has_space=`$ECHO "$complete" | $GREP " "`
15763         if test "x$has_space" != x; then
15764           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
15765 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
15766         fi
15767         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15768       fi
15769     fi
15770 
15771     # Now join together the path and the arguments once again
15772     if test "x$arguments" != xEOL; then
15773       new_complete="$new_path ${arguments% *}"
15774     else
15775       new_complete="$new_path"
15776     fi
15777 
15778     if test "x$complete" != "x$new_complete"; then
15779       FOUND_MAKE="$new_complete"
15780       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
15781 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
15782     fi
15783   fi
15784 
15785         fi
15786       fi
15787     fi
15788   fi
15789 
15790     if test "x$FOUND_MAKE" = x; then
15791       as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make 3.81 or newer." "$LINENO" 5
15792     fi
15793   else
15794     # Try our hardest to locate a correct version of GNU make
15795     for ac_prog in gmake
15796 do
15797   # Extract the first word of "$ac_prog", so it can be a program name with args.
15798 set dummy $ac_prog; ac_word=$2
15799 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15800 $as_echo_n "checking for $ac_word... " >&6; }
15801 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
15802   $as_echo_n "(cached) " >&6
15803 else
15804   case $CHECK_GMAKE in
15805   [\\/]* | ?:[\\/]*)
15806   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
15807   ;;
15808   *)
15809   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15810 for as_dir in $PATH
15811 do
15812   IFS=$as_save_IFS
15813   test -z "$as_dir" && as_dir=.
15814     for ac_exec_ext in '' $ac_executable_extensions; do
15815   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15816     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
15817     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15818     break 2
15819   fi
15820 done
15821   done
15822 IFS=$as_save_IFS
15823 
15824   ;;
15825 esac
15826 fi
15827 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
15828 if test -n "$CHECK_GMAKE"; then
15829   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
15830 $as_echo "$CHECK_GMAKE" >&6; }
15831 else
15832   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15833 $as_echo "no" >&6; }
15834 fi
15835 
15836 
15837   test -n "$CHECK_GMAKE" && break
15838 done
15839 
15840 
15841   MAKE_CANDIDATE=""$CHECK_GMAKE""
15842   DESCRIPTION="gmake in PATH"
15843   if test "x$MAKE_CANDIDATE" != x; then
15844     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15845 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15846     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15847     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15848     if test "x$IS_GNU_MAKE" = x; then
15849       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15850 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15851     else
15852       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15853       if test "x$IS_MODERN_MAKE" = x; then
15854         { $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
15855 $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;}
15856       else
15857         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15858           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15859             MAKE_EXPECTED_ENV='cygwin'
15860           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15861             MAKE_EXPECTED_ENV='msys'
15862           else
15863             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15864           fi
15865           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15866           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15867         else
15868           # Not relevant for non-Windows
15869           IS_MAKE_CORRECT_ENV=true
15870         fi
15871         if test "x$IS_MAKE_CORRECT_ENV" = x; then
15872           { $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
15873 $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;}
15874         else
15875           FOUND_MAKE=$MAKE_CANDIDATE
15876 
15877   # Only process if variable expands to non-empty
15878 
15879   if test "x$FOUND_MAKE" != x; then
15880     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15881 
15882   # First separate the path from the arguments. This will split at the first
15883   # space.
15884   complete="$FOUND_MAKE"
15885   path="${complete%% *}"
15886   tmp="$complete EOL"
15887   arguments="${tmp#* }"
15888 
15889   # Input might be given as Windows format, start by converting to
15890   # unix format.
15891   new_path=`$CYGPATH -u "$path"`
15892 
15893   # Now try to locate executable using which
15894   new_path=`$WHICH "$new_path" 2> /dev/null`
15895   # bat and cmd files are not always considered executable in cygwin causing which
15896   # to not find them
15897   if test "x$new_path" = x \
15898       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15899       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15900     new_path=`$CYGPATH -u "$path"`
15901   fi
15902   if test "x$new_path" = x; then
15903     # Oops. Which didn't find the executable.
15904     # The splitting of arguments from the executable at a space might have been incorrect,
15905     # since paths with space are more likely in Windows. Give it another try with the whole
15906     # argument.
15907     path="$complete"
15908     arguments="EOL"
15909     new_path=`$CYGPATH -u "$path"`
15910     new_path=`$WHICH "$new_path" 2> /dev/null`
15911     # bat and cmd files are not always considered executable in cygwin causing which
15912     # to not find them
15913     if test "x$new_path" = x \
15914         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15915         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15916       new_path=`$CYGPATH -u "$path"`
15917     fi
15918     if test "x$new_path" = x; then
15919       # It's still not found. Now this is an unrecoverable error.
15920       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15921 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15922       has_space=`$ECHO "$complete" | $GREP " "`
15923       if test "x$has_space" != x; then
15924         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15925 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15926       fi
15927       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15928     fi
15929   fi
15930 
15931   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15932   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15933   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15934   # "foo.exe" is OK but "foo" is an error.
15935   #
15936   # This test is therefore slightly more accurate than "test -f" to check for file presence.
15937   # It is also a way to make sure we got the proper file name for the real test later on.
15938   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15939   if test "x$test_shortpath" = x; then
15940     # Short path failed, file does not exist as specified.
15941     # Try adding .exe or .cmd
15942     if test -f "${new_path}.exe"; then
15943       input_to_shortpath="${new_path}.exe"
15944     elif test -f "${new_path}.cmd"; then
15945       input_to_shortpath="${new_path}.cmd"
15946     else
15947       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15948 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15949       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15950 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15951       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15952     fi
15953   else
15954     input_to_shortpath="$new_path"
15955   fi
15956 
15957   # Call helper function which possibly converts this using DOS-style short mode.
15958   # If so, the updated path is stored in $new_path.
15959   new_path="$input_to_shortpath"
15960 
15961   input_path="$input_to_shortpath"
15962   # Check if we need to convert this using DOS-style short mode. If the path
15963   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15964   # take no chances and rewrite it.
15965   # Note: m4 eats our [], so we need to use [ and ] instead.
15966   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15967   if test "x$has_forbidden_chars" != x; then
15968     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15969     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15970     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15971     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15972       # Going to short mode and back again did indeed matter. Since short mode is
15973       # case insensitive, let's make it lowercase to improve readability.
15974       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15975       # Now convert it back to Unix-stile (cygpath)
15976       input_path=`$CYGPATH -u "$shortmode_path"`
15977       new_path="$input_path"
15978     fi
15979   fi
15980 
15981   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15982   if test "x$test_cygdrive_prefix" = x; then
15983     # As a simple fix, exclude /usr/bin since it's not a real path.
15984     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15985       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15986       # a path prefixed by /cygdrive for fixpath to work.
15987       new_path="$CYGWIN_ROOT_PATH$input_path"
15988     fi
15989   fi
15990 
15991   # remove trailing .exe if any
15992   new_path="${new_path/%.exe/}"
15993 
15994     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15995 
15996   # First separate the path from the arguments. This will split at the first
15997   # space.
15998   complete="$FOUND_MAKE"
15999   path="${complete%% *}"
16000   tmp="$complete EOL"
16001   arguments="${tmp#* }"
16002 
16003   # Input might be given as Windows format, start by converting to
16004   # unix format.
16005   new_path="$path"
16006 
16007   windows_path="$new_path"
16008   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16009     unix_path=`$CYGPATH -u "$windows_path"`
16010     new_path="$unix_path"
16011   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16012     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16013     new_path="$unix_path"
16014   fi
16015 
16016 
16017   # Now try to locate executable using which
16018   new_path=`$WHICH "$new_path" 2> /dev/null`
16019 
16020   if test "x$new_path" = x; then
16021     # Oops. Which didn't find the executable.
16022     # The splitting of arguments from the executable at a space might have been incorrect,
16023     # since paths with space are more likely in Windows. Give it another try with the whole
16024     # argument.
16025     path="$complete"
16026     arguments="EOL"
16027     new_path="$path"
16028 
16029   windows_path="$new_path"
16030   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16031     unix_path=`$CYGPATH -u "$windows_path"`
16032     new_path="$unix_path"
16033   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16034     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16035     new_path="$unix_path"
16036   fi
16037 
16038 
16039     new_path=`$WHICH "$new_path" 2> /dev/null`
16040     # bat and cmd files are not always considered executable in MSYS causing which
16041     # to not find them
16042     if test "x$new_path" = x \
16043         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16044         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16045       new_path="$path"
16046 
16047   windows_path="$new_path"
16048   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16049     unix_path=`$CYGPATH -u "$windows_path"`
16050     new_path="$unix_path"
16051   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16052     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16053     new_path="$unix_path"
16054   fi
16055 
16056     fi
16057 
16058     if test "x$new_path" = x; then
16059       # It's still not found. Now this is an unrecoverable error.
16060       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16061 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16062       has_space=`$ECHO "$complete" | $GREP " "`
16063       if test "x$has_space" != x; then
16064         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16065 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16066       fi
16067       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16068     fi
16069   fi
16070 
16071   # Now new_path has a complete unix path to the binary
16072   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16073     # Keep paths in /bin as-is, but remove trailing .exe if any
16074     new_path="${new_path/%.exe/}"
16075     # Do not save /bin paths to all_fixpath_prefixes!
16076   else
16077     # Not in mixed or Windows style, start by that.
16078     new_path=`cmd //c echo $new_path`
16079 
16080   input_path="$new_path"
16081   # Check if we need to convert this using DOS-style short mode. If the path
16082   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16083   # take no chances and rewrite it.
16084   # Note: m4 eats our [], so we need to use [ and ] instead.
16085   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16086   if test "x$has_forbidden_chars" != x; then
16087     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16088     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16089   fi
16090 
16091     # Output is in $new_path
16092 
16093   windows_path="$new_path"
16094   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16095     unix_path=`$CYGPATH -u "$windows_path"`
16096     new_path="$unix_path"
16097   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16098     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16099     new_path="$unix_path"
16100   fi
16101 
16102     # remove trailing .exe if any
16103     new_path="${new_path/%.exe/}"
16104 
16105     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16106     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16107   fi
16108 
16109     else
16110       # We're on a unix platform. Hooray! :)
16111       # First separate the path from the arguments. This will split at the first
16112       # space.
16113       complete="$FOUND_MAKE"
16114       path="${complete%% *}"
16115       tmp="$complete EOL"
16116       arguments="${tmp#* }"
16117 
16118       # Cannot rely on the command "which" here since it doesn't always work.
16119       is_absolute_path=`$ECHO "$path" | $GREP ^/`
16120       if test -z "$is_absolute_path"; then
16121         # Path to executable is not absolute. Find it.
16122         IFS_save="$IFS"
16123         IFS=:
16124         for p in $PATH; do
16125           if test -f "$p/$path" && test -x "$p/$path"; then
16126             new_path="$p/$path"
16127             break
16128           fi
16129         done
16130         IFS="$IFS_save"
16131       else
16132         # This is an absolute path, we can use it without further modifications.
16133         new_path="$path"
16134       fi
16135 
16136       if test "x$new_path" = x; then
16137         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16138 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16139         has_space=`$ECHO "$complete" | $GREP " "`
16140         if test "x$has_space" != x; then
16141           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16142 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16143         fi
16144         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16145       fi
16146     fi
16147 
16148     # Now join together the path and the arguments once again
16149     if test "x$arguments" != xEOL; then
16150       new_complete="$new_path ${arguments% *}"
16151     else
16152       new_complete="$new_path"
16153     fi
16154 
16155     if test "x$complete" != "x$new_complete"; then
16156       FOUND_MAKE="$new_complete"
16157       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16158 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16159     fi
16160   fi
16161 
16162         fi
16163       fi
16164     fi
16165   fi
16166 
16167 
16168     if test "x$FOUND_MAKE" = x; then
16169       for ac_prog in make
16170 do
16171   # Extract the first word of "$ac_prog", so it can be a program name with args.
16172 set dummy $ac_prog; ac_word=$2
16173 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16174 $as_echo_n "checking for $ac_word... " >&6; }
16175 if ${ac_cv_path_CHECK_MAKE+:} false; then :
16176   $as_echo_n "(cached) " >&6
16177 else
16178   case $CHECK_MAKE in
16179   [\\/]* | ?:[\\/]*)
16180   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
16181   ;;
16182   *)
16183   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16184 for as_dir in $PATH
16185 do
16186   IFS=$as_save_IFS
16187   test -z "$as_dir" && as_dir=.
16188     for ac_exec_ext in '' $ac_executable_extensions; do
16189   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16190     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
16191     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16192     break 2
16193   fi
16194 done
16195   done
16196 IFS=$as_save_IFS
16197 
16198   ;;
16199 esac
16200 fi
16201 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
16202 if test -n "$CHECK_MAKE"; then
16203   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
16204 $as_echo "$CHECK_MAKE" >&6; }
16205 else
16206   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16207 $as_echo "no" >&6; }
16208 fi
16209 
16210 
16211   test -n "$CHECK_MAKE" && break
16212 done
16213 
16214 
16215   MAKE_CANDIDATE=""$CHECK_MAKE""
16216   DESCRIPTION="make in PATH"
16217   if test "x$MAKE_CANDIDATE" != x; then
16218     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16219 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16220     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16221     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16222     if test "x$IS_GNU_MAKE" = x; then
16223       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16224 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16225     else
16226       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
16227       if test "x$IS_MODERN_MAKE" = x; then
16228         { $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
16229 $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;}
16230       else
16231         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16232           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16233             MAKE_EXPECTED_ENV='cygwin'
16234           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16235             MAKE_EXPECTED_ENV='msys'
16236           else
16237             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16238           fi
16239           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16240           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16241         else
16242           # Not relevant for non-Windows
16243           IS_MAKE_CORRECT_ENV=true
16244         fi
16245         if test "x$IS_MAKE_CORRECT_ENV" = x; then
16246           { $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
16247 $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;}
16248         else
16249           FOUND_MAKE=$MAKE_CANDIDATE
16250 
16251   # Only process if variable expands to non-empty
16252 
16253   if test "x$FOUND_MAKE" != x; then
16254     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16255 
16256   # First separate the path from the arguments. This will split at the first
16257   # space.
16258   complete="$FOUND_MAKE"
16259   path="${complete%% *}"
16260   tmp="$complete EOL"
16261   arguments="${tmp#* }"
16262 
16263   # Input might be given as Windows format, start by converting to
16264   # unix format.
16265   new_path=`$CYGPATH -u "$path"`
16266 
16267   # Now try to locate executable using which
16268   new_path=`$WHICH "$new_path" 2> /dev/null`
16269   # bat and cmd files are not always considered executable in cygwin causing which
16270   # to not find them
16271   if test "x$new_path" = x \
16272       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16273       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16274     new_path=`$CYGPATH -u "$path"`
16275   fi
16276   if test "x$new_path" = x; then
16277     # Oops. Which didn't find the executable.
16278     # The splitting of arguments from the executable at a space might have been incorrect,
16279     # since paths with space are more likely in Windows. Give it another try with the whole
16280     # argument.
16281     path="$complete"
16282     arguments="EOL"
16283     new_path=`$CYGPATH -u "$path"`
16284     new_path=`$WHICH "$new_path" 2> /dev/null`
16285     # bat and cmd files are not always considered executable in cygwin causing which
16286     # to not find them
16287     if test "x$new_path" = x \
16288         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16289         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16290       new_path=`$CYGPATH -u "$path"`
16291     fi
16292     if test "x$new_path" = x; then
16293       # It's still not found. Now this is an unrecoverable error.
16294       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16295 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16296       has_space=`$ECHO "$complete" | $GREP " "`
16297       if test "x$has_space" != x; then
16298         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16299 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16300       fi
16301       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16302     fi
16303   fi
16304 
16305   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16306   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16307   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16308   # "foo.exe" is OK but "foo" is an error.
16309   #
16310   # This test is therefore slightly more accurate than "test -f" to check for file presence.
16311   # It is also a way to make sure we got the proper file name for the real test later on.
16312   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16313   if test "x$test_shortpath" = x; then
16314     # Short path failed, file does not exist as specified.
16315     # Try adding .exe or .cmd
16316     if test -f "${new_path}.exe"; then
16317       input_to_shortpath="${new_path}.exe"
16318     elif test -f "${new_path}.cmd"; then
16319       input_to_shortpath="${new_path}.cmd"
16320     else
16321       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16322 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16323       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16324 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16325       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16326     fi
16327   else
16328     input_to_shortpath="$new_path"
16329   fi
16330 
16331   # Call helper function which possibly converts this using DOS-style short mode.
16332   # If so, the updated path is stored in $new_path.
16333   new_path="$input_to_shortpath"
16334 
16335   input_path="$input_to_shortpath"
16336   # Check if we need to convert this using DOS-style short mode. If the path
16337   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16338   # take no chances and rewrite it.
16339   # Note: m4 eats our [], so we need to use [ and ] instead.
16340   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16341   if test "x$has_forbidden_chars" != x; then
16342     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16343     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16344     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16345     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16346       # Going to short mode and back again did indeed matter. Since short mode is
16347       # case insensitive, let's make it lowercase to improve readability.
16348       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16349       # Now convert it back to Unix-stile (cygpath)
16350       input_path=`$CYGPATH -u "$shortmode_path"`
16351       new_path="$input_path"
16352     fi
16353   fi
16354 
16355   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16356   if test "x$test_cygdrive_prefix" = x; then
16357     # As a simple fix, exclude /usr/bin since it's not a real path.
16358     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16359       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16360       # a path prefixed by /cygdrive for fixpath to work.
16361       new_path="$CYGWIN_ROOT_PATH$input_path"
16362     fi
16363   fi
16364 
16365   # remove trailing .exe if any
16366   new_path="${new_path/%.exe/}"
16367 
16368     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16369 
16370   # First separate the path from the arguments. This will split at the first
16371   # space.
16372   complete="$FOUND_MAKE"
16373   path="${complete%% *}"
16374   tmp="$complete EOL"
16375   arguments="${tmp#* }"
16376 
16377   # Input might be given as Windows format, start by converting to
16378   # unix format.
16379   new_path="$path"
16380 
16381   windows_path="$new_path"
16382   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16383     unix_path=`$CYGPATH -u "$windows_path"`
16384     new_path="$unix_path"
16385   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16386     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16387     new_path="$unix_path"
16388   fi
16389 
16390 
16391   # Now try to locate executable using which
16392   new_path=`$WHICH "$new_path" 2> /dev/null`
16393 
16394   if test "x$new_path" = x; then
16395     # Oops. Which didn't find the executable.
16396     # The splitting of arguments from the executable at a space might have been incorrect,
16397     # since paths with space are more likely in Windows. Give it another try with the whole
16398     # argument.
16399     path="$complete"
16400     arguments="EOL"
16401     new_path="$path"
16402 
16403   windows_path="$new_path"
16404   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16405     unix_path=`$CYGPATH -u "$windows_path"`
16406     new_path="$unix_path"
16407   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16408     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16409     new_path="$unix_path"
16410   fi
16411 
16412 
16413     new_path=`$WHICH "$new_path" 2> /dev/null`
16414     # bat and cmd files are not always considered executable in MSYS causing which
16415     # to not find them
16416     if test "x$new_path" = x \
16417         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16418         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16419       new_path="$path"
16420 
16421   windows_path="$new_path"
16422   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16423     unix_path=`$CYGPATH -u "$windows_path"`
16424     new_path="$unix_path"
16425   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16426     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16427     new_path="$unix_path"
16428   fi
16429 
16430     fi
16431 
16432     if test "x$new_path" = x; then
16433       # It's still not found. Now this is an unrecoverable error.
16434       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16435 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16436       has_space=`$ECHO "$complete" | $GREP " "`
16437       if test "x$has_space" != x; then
16438         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16439 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16440       fi
16441       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16442     fi
16443   fi
16444 
16445   # Now new_path has a complete unix path to the binary
16446   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16447     # Keep paths in /bin as-is, but remove trailing .exe if any
16448     new_path="${new_path/%.exe/}"
16449     # Do not save /bin paths to all_fixpath_prefixes!
16450   else
16451     # Not in mixed or Windows style, start by that.
16452     new_path=`cmd //c echo $new_path`
16453 
16454   input_path="$new_path"
16455   # Check if we need to convert this using DOS-style short mode. If the path
16456   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16457   # take no chances and rewrite it.
16458   # Note: m4 eats our [], so we need to use [ and ] instead.
16459   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16460   if test "x$has_forbidden_chars" != x; then
16461     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16462     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16463   fi
16464 
16465     # Output is in $new_path
16466 
16467   windows_path="$new_path"
16468   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16469     unix_path=`$CYGPATH -u "$windows_path"`
16470     new_path="$unix_path"
16471   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16472     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16473     new_path="$unix_path"
16474   fi
16475 
16476     # remove trailing .exe if any
16477     new_path="${new_path/%.exe/}"
16478 
16479     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16480     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16481   fi
16482 
16483     else
16484       # We're on a unix platform. Hooray! :)
16485       # First separate the path from the arguments. This will split at the first
16486       # space.
16487       complete="$FOUND_MAKE"
16488       path="${complete%% *}"
16489       tmp="$complete EOL"
16490       arguments="${tmp#* }"
16491 
16492       # Cannot rely on the command "which" here since it doesn't always work.
16493       is_absolute_path=`$ECHO "$path" | $GREP ^/`
16494       if test -z "$is_absolute_path"; then
16495         # Path to executable is not absolute. Find it.
16496         IFS_save="$IFS"
16497         IFS=:
16498         for p in $PATH; do
16499           if test -f "$p/$path" && test -x "$p/$path"; then
16500             new_path="$p/$path"
16501             break
16502           fi
16503         done
16504         IFS="$IFS_save"
16505       else
16506         # This is an absolute path, we can use it without further modifications.
16507         new_path="$path"
16508       fi
16509 
16510       if test "x$new_path" = x; then
16511         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16512 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16513         has_space=`$ECHO "$complete" | $GREP " "`
16514         if test "x$has_space" != x; then
16515           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16516 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16517         fi
16518         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16519       fi
16520     fi
16521 
16522     # Now join together the path and the arguments once again
16523     if test "x$arguments" != xEOL; then
16524       new_complete="$new_path ${arguments% *}"
16525     else
16526       new_complete="$new_path"
16527     fi
16528 
16529     if test "x$complete" != "x$new_complete"; then
16530       FOUND_MAKE="$new_complete"
16531       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16532 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16533     fi
16534   fi
16535 
16536         fi
16537       fi
16538     fi
16539   fi
16540 
16541     fi
16542 
16543     if test "x$FOUND_MAKE" = x; then
16544       if test "x$TOOLCHAIN_PATH" != x; then
16545         # We have a toolchain path, check that as well before giving up.
16546         OLD_PATH=$PATH
16547         PATH=$TOOLCHAIN_PATH:$PATH
16548         for ac_prog in gmake
16549 do
16550   # Extract the first word of "$ac_prog", so it can be a program name with args.
16551 set dummy $ac_prog; ac_word=$2
16552 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16553 $as_echo_n "checking for $ac_word... " >&6; }
16554 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
16555   $as_echo_n "(cached) " >&6
16556 else
16557   case $CHECK_TOOLSDIR_GMAKE in
16558   [\\/]* | ?:[\\/]*)
16559   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
16560   ;;
16561   *)
16562   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16563 for as_dir in $PATH
16564 do
16565   IFS=$as_save_IFS
16566   test -z "$as_dir" && as_dir=.
16567     for ac_exec_ext in '' $ac_executable_extensions; do
16568   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16569     ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
16570     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16571     break 2
16572   fi
16573 done
16574   done
16575 IFS=$as_save_IFS
16576 
16577   ;;
16578 esac
16579 fi
16580 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
16581 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
16582   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
16583 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
16584 else
16585   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16586 $as_echo "no" >&6; }
16587 fi
16588 
16589 
16590   test -n "$CHECK_TOOLSDIR_GMAKE" && break
16591 done
16592 
16593 
16594   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
16595   DESCRIPTION="gmake in tools-dir"
16596   if test "x$MAKE_CANDIDATE" != x; then
16597     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16598 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16599     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16600     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16601     if test "x$IS_GNU_MAKE" = x; then
16602       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16603 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16604     else
16605       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
16606       if test "x$IS_MODERN_MAKE" = x; then
16607         { $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
16608 $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;}
16609       else
16610         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16611           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16612             MAKE_EXPECTED_ENV='cygwin'
16613           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16614             MAKE_EXPECTED_ENV='msys'
16615           else
16616             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16617           fi
16618           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16619           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16620         else
16621           # Not relevant for non-Windows
16622           IS_MAKE_CORRECT_ENV=true
16623         fi
16624         if test "x$IS_MAKE_CORRECT_ENV" = x; then
16625           { $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
16626 $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;}
16627         else
16628           FOUND_MAKE=$MAKE_CANDIDATE
16629 
16630   # Only process if variable expands to non-empty
16631 
16632   if test "x$FOUND_MAKE" != x; then
16633     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16634 
16635   # First separate the path from the arguments. This will split at the first
16636   # space.
16637   complete="$FOUND_MAKE"
16638   path="${complete%% *}"
16639   tmp="$complete EOL"
16640   arguments="${tmp#* }"
16641 
16642   # Input might be given as Windows format, start by converting to
16643   # unix format.
16644   new_path=`$CYGPATH -u "$path"`
16645 
16646   # Now try to locate executable using which
16647   new_path=`$WHICH "$new_path" 2> /dev/null`
16648   # bat and cmd files are not always considered executable in cygwin causing which
16649   # to not find them
16650   if test "x$new_path" = x \
16651       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16652       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16653     new_path=`$CYGPATH -u "$path"`
16654   fi
16655   if test "x$new_path" = x; then
16656     # Oops. Which didn't find the executable.
16657     # The splitting of arguments from the executable at a space might have been incorrect,
16658     # since paths with space are more likely in Windows. Give it another try with the whole
16659     # argument.
16660     path="$complete"
16661     arguments="EOL"
16662     new_path=`$CYGPATH -u "$path"`
16663     new_path=`$WHICH "$new_path" 2> /dev/null`
16664     # bat and cmd files are not always considered executable in cygwin causing which
16665     # to not find them
16666     if test "x$new_path" = x \
16667         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16668         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16669       new_path=`$CYGPATH -u "$path"`
16670     fi
16671     if test "x$new_path" = x; then
16672       # It's still not found. Now this is an unrecoverable error.
16673       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16674 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16675       has_space=`$ECHO "$complete" | $GREP " "`
16676       if test "x$has_space" != x; then
16677         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16678 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16679       fi
16680       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16681     fi
16682   fi
16683 
16684   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16685   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16686   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16687   # "foo.exe" is OK but "foo" is an error.
16688   #
16689   # This test is therefore slightly more accurate than "test -f" to check for file presence.
16690   # It is also a way to make sure we got the proper file name for the real test later on.
16691   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16692   if test "x$test_shortpath" = x; then
16693     # Short path failed, file does not exist as specified.
16694     # Try adding .exe or .cmd
16695     if test -f "${new_path}.exe"; then
16696       input_to_shortpath="${new_path}.exe"
16697     elif test -f "${new_path}.cmd"; then
16698       input_to_shortpath="${new_path}.cmd"
16699     else
16700       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16701 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16702       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16703 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16704       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16705     fi
16706   else
16707     input_to_shortpath="$new_path"
16708   fi
16709 
16710   # Call helper function which possibly converts this using DOS-style short mode.
16711   # If so, the updated path is stored in $new_path.
16712   new_path="$input_to_shortpath"
16713 
16714   input_path="$input_to_shortpath"
16715   # Check if we need to convert this using DOS-style short mode. If the path
16716   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16717   # take no chances and rewrite it.
16718   # Note: m4 eats our [], so we need to use [ and ] instead.
16719   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16720   if test "x$has_forbidden_chars" != x; then
16721     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16722     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16723     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16724     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16725       # Going to short mode and back again did indeed matter. Since short mode is
16726       # case insensitive, let's make it lowercase to improve readability.
16727       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16728       # Now convert it back to Unix-stile (cygpath)
16729       input_path=`$CYGPATH -u "$shortmode_path"`
16730       new_path="$input_path"
16731     fi
16732   fi
16733 
16734   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16735   if test "x$test_cygdrive_prefix" = x; then
16736     # As a simple fix, exclude /usr/bin since it's not a real path.
16737     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16738       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16739       # a path prefixed by /cygdrive for fixpath to work.
16740       new_path="$CYGWIN_ROOT_PATH$input_path"
16741     fi
16742   fi
16743 
16744   # remove trailing .exe if any
16745   new_path="${new_path/%.exe/}"
16746 
16747     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16748 
16749   # First separate the path from the arguments. This will split at the first
16750   # space.
16751   complete="$FOUND_MAKE"
16752   path="${complete%% *}"
16753   tmp="$complete EOL"
16754   arguments="${tmp#* }"
16755 
16756   # Input might be given as Windows format, start by converting to
16757   # unix format.
16758   new_path="$path"
16759 
16760   windows_path="$new_path"
16761   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16762     unix_path=`$CYGPATH -u "$windows_path"`
16763     new_path="$unix_path"
16764   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16765     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16766     new_path="$unix_path"
16767   fi
16768 
16769 
16770   # Now try to locate executable using which
16771   new_path=`$WHICH "$new_path" 2> /dev/null`
16772 
16773   if test "x$new_path" = x; then
16774     # Oops. Which didn't find the executable.
16775     # The splitting of arguments from the executable at a space might have been incorrect,
16776     # since paths with space are more likely in Windows. Give it another try with the whole
16777     # argument.
16778     path="$complete"
16779     arguments="EOL"
16780     new_path="$path"
16781 
16782   windows_path="$new_path"
16783   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16784     unix_path=`$CYGPATH -u "$windows_path"`
16785     new_path="$unix_path"
16786   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16787     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16788     new_path="$unix_path"
16789   fi
16790 
16791 
16792     new_path=`$WHICH "$new_path" 2> /dev/null`
16793     # bat and cmd files are not always considered executable in MSYS causing which
16794     # to not find them
16795     if test "x$new_path" = x \
16796         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16797         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16798       new_path="$path"
16799 
16800   windows_path="$new_path"
16801   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16802     unix_path=`$CYGPATH -u "$windows_path"`
16803     new_path="$unix_path"
16804   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16805     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16806     new_path="$unix_path"
16807   fi
16808 
16809     fi
16810 
16811     if test "x$new_path" = x; then
16812       # It's still not found. Now this is an unrecoverable error.
16813       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16814 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16815       has_space=`$ECHO "$complete" | $GREP " "`
16816       if test "x$has_space" != x; then
16817         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16818 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16819       fi
16820       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16821     fi
16822   fi
16823 
16824   # Now new_path has a complete unix path to the binary
16825   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16826     # Keep paths in /bin as-is, but remove trailing .exe if any
16827     new_path="${new_path/%.exe/}"
16828     # Do not save /bin paths to all_fixpath_prefixes!
16829   else
16830     # Not in mixed or Windows style, start by that.
16831     new_path=`cmd //c echo $new_path`
16832 
16833   input_path="$new_path"
16834   # Check if we need to convert this using DOS-style short mode. If the path
16835   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16836   # take no chances and rewrite it.
16837   # Note: m4 eats our [], so we need to use [ and ] instead.
16838   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16839   if test "x$has_forbidden_chars" != x; then
16840     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16841     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16842   fi
16843 
16844     # Output is in $new_path
16845 
16846   windows_path="$new_path"
16847   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16848     unix_path=`$CYGPATH -u "$windows_path"`
16849     new_path="$unix_path"
16850   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16851     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16852     new_path="$unix_path"
16853   fi
16854 
16855     # remove trailing .exe if any
16856     new_path="${new_path/%.exe/}"
16857 
16858     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16859     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16860   fi
16861 
16862     else
16863       # We're on a unix platform. Hooray! :)
16864       # First separate the path from the arguments. This will split at the first
16865       # space.
16866       complete="$FOUND_MAKE"
16867       path="${complete%% *}"
16868       tmp="$complete EOL"
16869       arguments="${tmp#* }"
16870 
16871       # Cannot rely on the command "which" here since it doesn't always work.
16872       is_absolute_path=`$ECHO "$path" | $GREP ^/`
16873       if test -z "$is_absolute_path"; then
16874         # Path to executable is not absolute. Find it.
16875         IFS_save="$IFS"
16876         IFS=:
16877         for p in $PATH; do
16878           if test -f "$p/$path" && test -x "$p/$path"; then
16879             new_path="$p/$path"
16880             break
16881           fi
16882         done
16883         IFS="$IFS_save"
16884       else
16885         # This is an absolute path, we can use it without further modifications.
16886         new_path="$path"
16887       fi
16888 
16889       if test "x$new_path" = x; then
16890         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16891 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16892         has_space=`$ECHO "$complete" | $GREP " "`
16893         if test "x$has_space" != x; then
16894           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16895 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16896         fi
16897         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16898       fi
16899     fi
16900 
16901     # Now join together the path and the arguments once again
16902     if test "x$arguments" != xEOL; then
16903       new_complete="$new_path ${arguments% *}"
16904     else
16905       new_complete="$new_path"
16906     fi
16907 
16908     if test "x$complete" != "x$new_complete"; then
16909       FOUND_MAKE="$new_complete"
16910       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16911 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16912     fi
16913   fi
16914 
16915         fi
16916       fi
16917     fi
16918   fi
16919 
16920         if test "x$FOUND_MAKE" = x; then
16921           for ac_prog in make
16922 do
16923   # Extract the first word of "$ac_prog", so it can be a program name with args.
16924 set dummy $ac_prog; ac_word=$2
16925 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16926 $as_echo_n "checking for $ac_word... " >&6; }
16927 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
16928   $as_echo_n "(cached) " >&6
16929 else
16930   case $CHECK_TOOLSDIR_MAKE in
16931   [\\/]* | ?:[\\/]*)
16932   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
16933   ;;
16934   *)
16935   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16936 for as_dir in $PATH
16937 do
16938   IFS=$as_save_IFS
16939   test -z "$as_dir" && as_dir=.
16940     for ac_exec_ext in '' $ac_executable_extensions; do
16941   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16942     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
16943     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16944     break 2
16945   fi
16946 done
16947   done
16948 IFS=$as_save_IFS
16949 
16950   ;;
16951 esac
16952 fi
16953 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
16954 if test -n "$CHECK_TOOLSDIR_MAKE"; then
16955   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
16956 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
16957 else
16958   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16959 $as_echo "no" >&6; }
16960 fi
16961 
16962 
16963   test -n "$CHECK_TOOLSDIR_MAKE" && break
16964 done
16965 
16966 
16967   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
16968   DESCRIPTION="make in tools-dir"
16969   if test "x$MAKE_CANDIDATE" != x; then
16970     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16971 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16972     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16973     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16974     if test "x$IS_GNU_MAKE" = x; then
16975       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16976 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16977     else
16978       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
16979       if test "x$IS_MODERN_MAKE" = x; then
16980         { $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
16981 $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;}
16982       else
16983         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16984           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16985             MAKE_EXPECTED_ENV='cygwin'
16986           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16987             MAKE_EXPECTED_ENV='msys'
16988           else
16989             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16990           fi
16991           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16992           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16993         else
16994           # Not relevant for non-Windows
16995           IS_MAKE_CORRECT_ENV=true
16996         fi
16997         if test "x$IS_MAKE_CORRECT_ENV" = x; then
16998           { $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
16999 $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;}
17000         else
17001           FOUND_MAKE=$MAKE_CANDIDATE
17002 
17003   # Only process if variable expands to non-empty
17004 
17005   if test "x$FOUND_MAKE" != x; then
17006     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17007 
17008   # First separate the path from the arguments. This will split at the first
17009   # space.
17010   complete="$FOUND_MAKE"
17011   path="${complete%% *}"
17012   tmp="$complete EOL"
17013   arguments="${tmp#* }"
17014 
17015   # Input might be given as Windows format, start by converting to
17016   # unix format.
17017   new_path=`$CYGPATH -u "$path"`
17018 
17019   # Now try to locate executable using which
17020   new_path=`$WHICH "$new_path" 2> /dev/null`
17021   # bat and cmd files are not always considered executable in cygwin causing which
17022   # to not find them
17023   if test "x$new_path" = x \
17024       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17025       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17026     new_path=`$CYGPATH -u "$path"`
17027   fi
17028   if test "x$new_path" = x; then
17029     # Oops. Which didn't find the executable.
17030     # The splitting of arguments from the executable at a space might have been incorrect,
17031     # since paths with space are more likely in Windows. Give it another try with the whole
17032     # argument.
17033     path="$complete"
17034     arguments="EOL"
17035     new_path=`$CYGPATH -u "$path"`
17036     new_path=`$WHICH "$new_path" 2> /dev/null`
17037     # bat and cmd files are not always considered executable in cygwin causing which
17038     # to not find them
17039     if test "x$new_path" = x \
17040         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17041         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17042       new_path=`$CYGPATH -u "$path"`
17043     fi
17044     if test "x$new_path" = x; then
17045       # It's still not found. Now this is an unrecoverable error.
17046       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17047 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17048       has_space=`$ECHO "$complete" | $GREP " "`
17049       if test "x$has_space" != x; then
17050         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17051 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17052       fi
17053       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17054     fi
17055   fi
17056 
17057   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17058   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17059   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17060   # "foo.exe" is OK but "foo" is an error.
17061   #
17062   # This test is therefore slightly more accurate than "test -f" to check for file presence.
17063   # It is also a way to make sure we got the proper file name for the real test later on.
17064   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17065   if test "x$test_shortpath" = x; then
17066     # Short path failed, file does not exist as specified.
17067     # Try adding .exe or .cmd
17068     if test -f "${new_path}.exe"; then
17069       input_to_shortpath="${new_path}.exe"
17070     elif test -f "${new_path}.cmd"; then
17071       input_to_shortpath="${new_path}.cmd"
17072     else
17073       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17074 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17075       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17076 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17077       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17078     fi
17079   else
17080     input_to_shortpath="$new_path"
17081   fi
17082 
17083   # Call helper function which possibly converts this using DOS-style short mode.
17084   # If so, the updated path is stored in $new_path.
17085   new_path="$input_to_shortpath"
17086 
17087   input_path="$input_to_shortpath"
17088   # Check if we need to convert this using DOS-style short mode. If the path
17089   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17090   # take no chances and rewrite it.
17091   # Note: m4 eats our [], so we need to use [ and ] instead.
17092   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17093   if test "x$has_forbidden_chars" != x; then
17094     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17095     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17096     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17097     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17098       # Going to short mode and back again did indeed matter. Since short mode is
17099       # case insensitive, let's make it lowercase to improve readability.
17100       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17101       # Now convert it back to Unix-stile (cygpath)
17102       input_path=`$CYGPATH -u "$shortmode_path"`
17103       new_path="$input_path"
17104     fi
17105   fi
17106 
17107   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17108   if test "x$test_cygdrive_prefix" = x; then
17109     # As a simple fix, exclude /usr/bin since it's not a real path.
17110     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17111       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17112       # a path prefixed by /cygdrive for fixpath to work.
17113       new_path="$CYGWIN_ROOT_PATH$input_path"
17114     fi
17115   fi
17116 
17117   # remove trailing .exe if any
17118   new_path="${new_path/%.exe/}"
17119 
17120     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17121 
17122   # First separate the path from the arguments. This will split at the first
17123   # space.
17124   complete="$FOUND_MAKE"
17125   path="${complete%% *}"
17126   tmp="$complete EOL"
17127   arguments="${tmp#* }"
17128 
17129   # Input might be given as Windows format, start by converting to
17130   # unix format.
17131   new_path="$path"
17132 
17133   windows_path="$new_path"
17134   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17135     unix_path=`$CYGPATH -u "$windows_path"`
17136     new_path="$unix_path"
17137   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17138     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17139     new_path="$unix_path"
17140   fi
17141 
17142 
17143   # Now try to locate executable using which
17144   new_path=`$WHICH "$new_path" 2> /dev/null`
17145 
17146   if test "x$new_path" = x; then
17147     # Oops. Which didn't find the executable.
17148     # The splitting of arguments from the executable at a space might have been incorrect,
17149     # since paths with space are more likely in Windows. Give it another try with the whole
17150     # argument.
17151     path="$complete"
17152     arguments="EOL"
17153     new_path="$path"
17154 
17155   windows_path="$new_path"
17156   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17157     unix_path=`$CYGPATH -u "$windows_path"`
17158     new_path="$unix_path"
17159   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17160     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17161     new_path="$unix_path"
17162   fi
17163 
17164 
17165     new_path=`$WHICH "$new_path" 2> /dev/null`
17166     # bat and cmd files are not always considered executable in MSYS causing which
17167     # to not find them
17168     if test "x$new_path" = x \
17169         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17170         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17171       new_path="$path"
17172 
17173   windows_path="$new_path"
17174   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17175     unix_path=`$CYGPATH -u "$windows_path"`
17176     new_path="$unix_path"
17177   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17178     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17179     new_path="$unix_path"
17180   fi
17181 
17182     fi
17183 
17184     if test "x$new_path" = x; then
17185       # It's still not found. Now this is an unrecoverable error.
17186       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17187 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17188       has_space=`$ECHO "$complete" | $GREP " "`
17189       if test "x$has_space" != x; then
17190         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17191 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17192       fi
17193       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17194     fi
17195   fi
17196 
17197   # Now new_path has a complete unix path to the binary
17198   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17199     # Keep paths in /bin as-is, but remove trailing .exe if any
17200     new_path="${new_path/%.exe/}"
17201     # Do not save /bin paths to all_fixpath_prefixes!
17202   else
17203     # Not in mixed or Windows style, start by that.
17204     new_path=`cmd //c echo $new_path`
17205 
17206   input_path="$new_path"
17207   # Check if we need to convert this using DOS-style short mode. If the path
17208   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17209   # take no chances and rewrite it.
17210   # Note: m4 eats our [], so we need to use [ and ] instead.
17211   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17212   if test "x$has_forbidden_chars" != x; then
17213     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17214     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17215   fi
17216 
17217     # Output is in $new_path
17218 
17219   windows_path="$new_path"
17220   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17221     unix_path=`$CYGPATH -u "$windows_path"`
17222     new_path="$unix_path"
17223   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17224     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17225     new_path="$unix_path"
17226   fi
17227 
17228     # remove trailing .exe if any
17229     new_path="${new_path/%.exe/}"
17230 
17231     # Save the first 10 bytes of this path to the storage, so fixpath can work.
17232     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17233   fi
17234 
17235     else
17236       # We're on a unix platform. Hooray! :)
17237       # First separate the path from the arguments. This will split at the first
17238       # space.
17239       complete="$FOUND_MAKE"
17240       path="${complete%% *}"
17241       tmp="$complete EOL"
17242       arguments="${tmp#* }"
17243 
17244       # Cannot rely on the command "which" here since it doesn't always work.
17245       is_absolute_path=`$ECHO "$path" | $GREP ^/`
17246       if test -z "$is_absolute_path"; then
17247         # Path to executable is not absolute. Find it.
17248         IFS_save="$IFS"
17249         IFS=:
17250         for p in $PATH; do
17251           if test -f "$p/$path" && test -x "$p/$path"; then
17252             new_path="$p/$path"
17253             break
17254           fi
17255         done
17256         IFS="$IFS_save"
17257       else
17258         # This is an absolute path, we can use it without further modifications.
17259         new_path="$path"
17260       fi
17261 
17262       if test "x$new_path" = x; then
17263         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17264 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17265         has_space=`$ECHO "$complete" | $GREP " "`
17266         if test "x$has_space" != x; then
17267           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17268 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17269         fi
17270         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17271       fi
17272     fi
17273 
17274     # Now join together the path and the arguments once again
17275     if test "x$arguments" != xEOL; then
17276       new_complete="$new_path ${arguments% *}"
17277     else
17278       new_complete="$new_path"
17279     fi
17280 
17281     if test "x$complete" != "x$new_complete"; then
17282       FOUND_MAKE="$new_complete"
17283       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17284 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17285     fi
17286   fi
17287 
17288         fi
17289       fi
17290     fi
17291   fi
17292 
17293         fi
17294         PATH=$OLD_PATH
17295       fi
17296     fi
17297 
17298     if test "x$FOUND_MAKE" = x; then
17299       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
17300     fi
17301   fi
17302 
17303   MAKE=$FOUND_MAKE
17304 
17305   { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
17306 $as_echo "$as_me: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
17307 
17308 
17309   # Check if make supports the output sync option and if so, setup using it.
17310   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if make --output-sync is supported" >&5
17311 $as_echo_n "checking if make --output-sync is supported... " >&6; }
17312   if $MAKE --version -O > /dev/null 2>&1; then
17313     OUTPUT_SYNC_SUPPORTED=true
17314     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
17315 $as_echo "yes" >&6; }
17316     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for output-sync value" >&5
17317 $as_echo_n "checking for output-sync value... " >&6; }
17318 
17319 # Check whether --with-output-sync was given.
17320 if test "${with_output_sync+set}" = set; then :
17321   withval=$with_output_sync; OUTPUT_SYNC=$with_output_sync
17322 fi
17323 
17324     if test "x$OUTPUT_SYNC" = "x"; then
17325       OUTPUT_SYNC=none
17326     fi
17327     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_SYNC" >&5
17328 $as_echo "$OUTPUT_SYNC" >&6; }
17329     if ! $MAKE --version -O$OUTPUT_SYNC > /dev/null 2>&1; then
17330       as_fn_error $? "Make did not the support the value $OUTPUT_SYNC as output sync type." "$LINENO" 5
17331     fi
17332   else
17333     OUTPUT_SYNC_SUPPORTED=false
17334     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17335 $as_echo "no" >&6; }
17336   fi
17337 
17338 
17339 
17340 
17341 
17342 
17343   # Test if find supports -delete
17344   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
17345 $as_echo_n "checking if find supports -delete... " >&6; }
17346   FIND_DELETE="-delete"
17347 
17348   DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
17349 
17350   echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
17351 
17352   TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
17353   if test -f $DELETEDIR/TestIfFindSupportsDelete; then
17354     # No, it does not.
17355     rm $DELETEDIR/TestIfFindSupportsDelete
17356     if test "x$OPENJDK_TARGET_OS" = "xaix"; then
17357       # AIX 'find' is buggy if called with '-exec {} \+' and an empty file list
17358       FIND_DELETE="-print | xargs rm"
17359     else
17360       FIND_DELETE="-exec rm \{\} \+"
17361     fi
17362     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17363 $as_echo "no" >&6; }
17364   else
17365     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
17366 $as_echo "yes" >&6; }
17367   fi
17368   rmdir $DELETEDIR
17369 
17370 
17371 
17372   # These tools might not be installed by default,
17373   # need hint on how to install them.
17374 
17375 
17376 
17377   # Publish this variable in the help.
17378 
17379 
17380   if test "x$UNZIP" = x; then
17381     # The variable is not set by user, try to locate tool using the code snippet
17382     for ac_prog in unzip
17383 do
17384   # Extract the first word of "$ac_prog", so it can be a program name with args.
17385 set dummy $ac_prog; ac_word=$2
17386 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17387 $as_echo_n "checking for $ac_word... " >&6; }
17388 if ${ac_cv_path_UNZIP+:} false; then :
17389   $as_echo_n "(cached) " >&6
17390 else
17391   case $UNZIP in
17392   [\\/]* | ?:[\\/]*)
17393   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17394   ;;
17395   *)
17396   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17397 for as_dir in $PATH
17398 do
17399   IFS=$as_save_IFS
17400   test -z "$as_dir" && as_dir=.
17401     for ac_exec_ext in '' $ac_executable_extensions; do
17402   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17403     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17404     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17405     break 2
17406   fi
17407 done
17408   done
17409 IFS=$as_save_IFS
17410 
17411   ;;
17412 esac
17413 fi
17414 UNZIP=$ac_cv_path_UNZIP
17415 if test -n "$UNZIP"; then
17416   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17417 $as_echo "$UNZIP" >&6; }
17418 else
17419   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17420 $as_echo "no" >&6; }
17421 fi
17422 
17423 
17424   test -n "$UNZIP" && break
17425 done
17426 
17427   else
17428     # The variable is set, but is it from the command line or the environment?
17429 
17430     # Try to remove the string !UNZIP! from our list.
17431     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
17432     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17433       # If it failed, the variable was not from the command line. Ignore it,
17434       # but warn the user (except for BASH, which is always set by the calling BASH).
17435       if test "xUNZIP" != xBASH; then
17436         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
17437 $as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
17438       fi
17439       # Try to locate tool using the code snippet
17440       for ac_prog in unzip
17441 do
17442   # Extract the first word of "$ac_prog", so it can be a program name with args.
17443 set dummy $ac_prog; ac_word=$2
17444 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17445 $as_echo_n "checking for $ac_word... " >&6; }
17446 if ${ac_cv_path_UNZIP+:} false; then :
17447   $as_echo_n "(cached) " >&6
17448 else
17449   case $UNZIP in
17450   [\\/]* | ?:[\\/]*)
17451   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17452   ;;
17453   *)
17454   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17455 for as_dir in $PATH
17456 do
17457   IFS=$as_save_IFS
17458   test -z "$as_dir" && as_dir=.
17459     for ac_exec_ext in '' $ac_executable_extensions; do
17460   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17461     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17462     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17463     break 2
17464   fi
17465 done
17466   done
17467 IFS=$as_save_IFS
17468 
17469   ;;
17470 esac
17471 fi
17472 UNZIP=$ac_cv_path_UNZIP
17473 if test -n "$UNZIP"; then
17474   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17475 $as_echo "$UNZIP" >&6; }
17476 else
17477   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17478 $as_echo "no" >&6; }
17479 fi
17480 
17481 
17482   test -n "$UNZIP" && break
17483 done
17484 
17485     else
17486       # If it succeeded, then it was overridden by the user. We will use it
17487       # for the tool.
17488 
17489       # First remove it from the list of overridden variables, so we can test
17490       # for unknown variables in the end.
17491       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17492 
17493       # Check if the provided tool contains a complete path.
17494       tool_specified="$UNZIP"
17495       tool_basename="${tool_specified##*/}"
17496       if test "x$tool_basename" = "x$tool_specified"; then
17497         # A command without a complete path is provided, search $PATH.
17498         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
17499 $as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
17500         # Extract the first word of "$tool_basename", so it can be a program name with args.
17501 set dummy $tool_basename; ac_word=$2
17502 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17503 $as_echo_n "checking for $ac_word... " >&6; }
17504 if ${ac_cv_path_UNZIP+:} false; then :
17505   $as_echo_n "(cached) " >&6
17506 else
17507   case $UNZIP in
17508   [\\/]* | ?:[\\/]*)
17509   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17510   ;;
17511   *)
17512   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17513 for as_dir in $PATH
17514 do
17515   IFS=$as_save_IFS
17516   test -z "$as_dir" && as_dir=.
17517     for ac_exec_ext in '' $ac_executable_extensions; do
17518   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17519     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17520     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17521     break 2
17522   fi
17523 done
17524   done
17525 IFS=$as_save_IFS
17526 
17527   ;;
17528 esac
17529 fi
17530 UNZIP=$ac_cv_path_UNZIP
17531 if test -n "$UNZIP"; then
17532   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17533 $as_echo "$UNZIP" >&6; }
17534 else
17535   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17536 $as_echo "no" >&6; }
17537 fi
17538 
17539 
17540         if test "x$UNZIP" = x; then
17541           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17542         fi
17543       else
17544         # Otherwise we believe it is a complete path. Use it as it is.
17545         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
17546 $as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
17547         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
17548 $as_echo_n "checking for UNZIP... " >&6; }
17549         if test ! -x "$tool_specified"; then
17550           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17551 $as_echo "not found" >&6; }
17552           as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17553         fi
17554         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17555 $as_echo "$tool_specified" >&6; }
17556       fi
17557     fi
17558   fi
17559 
17560 
17561 
17562   if test "x$UNZIP" = x; then
17563     as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
17564   fi
17565 
17566 
17567 
17568 
17569 
17570   # Publish this variable in the help.
17571 
17572 
17573   if test "x$ZIP" = x; then
17574     # The variable is not set by user, try to locate tool using the code snippet
17575     for ac_prog in zip
17576 do
17577   # Extract the first word of "$ac_prog", so it can be a program name with args.
17578 set dummy $ac_prog; ac_word=$2
17579 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17580 $as_echo_n "checking for $ac_word... " >&6; }
17581 if ${ac_cv_path_ZIP+:} false; then :
17582   $as_echo_n "(cached) " >&6
17583 else
17584   case $ZIP in
17585   [\\/]* | ?:[\\/]*)
17586   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17587   ;;
17588   *)
17589   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17590 for as_dir in $PATH
17591 do
17592   IFS=$as_save_IFS
17593   test -z "$as_dir" && as_dir=.
17594     for ac_exec_ext in '' $ac_executable_extensions; do
17595   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17596     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17597     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17598     break 2
17599   fi
17600 done
17601   done
17602 IFS=$as_save_IFS
17603 
17604   ;;
17605 esac
17606 fi
17607 ZIP=$ac_cv_path_ZIP
17608 if test -n "$ZIP"; then
17609   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17610 $as_echo "$ZIP" >&6; }
17611 else
17612   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17613 $as_echo "no" >&6; }
17614 fi
17615 
17616 
17617   test -n "$ZIP" && break
17618 done
17619 
17620   else
17621     # The variable is set, but is it from the command line or the environment?
17622 
17623     # Try to remove the string !ZIP! from our list.
17624     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIP!/}
17625     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17626       # If it failed, the variable was not from the command line. Ignore it,
17627       # but warn the user (except for BASH, which is always set by the calling BASH).
17628       if test "xZIP" != xBASH; then
17629         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
17630 $as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
17631       fi
17632       # Try to locate tool using the code snippet
17633       for ac_prog in zip
17634 do
17635   # Extract the first word of "$ac_prog", so it can be a program name with args.
17636 set dummy $ac_prog; ac_word=$2
17637 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17638 $as_echo_n "checking for $ac_word... " >&6; }
17639 if ${ac_cv_path_ZIP+:} false; then :
17640   $as_echo_n "(cached) " >&6
17641 else
17642   case $ZIP in
17643   [\\/]* | ?:[\\/]*)
17644   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17645   ;;
17646   *)
17647   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17648 for as_dir in $PATH
17649 do
17650   IFS=$as_save_IFS
17651   test -z "$as_dir" && as_dir=.
17652     for ac_exec_ext in '' $ac_executable_extensions; do
17653   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17654     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17655     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17656     break 2
17657   fi
17658 done
17659   done
17660 IFS=$as_save_IFS
17661 
17662   ;;
17663 esac
17664 fi
17665 ZIP=$ac_cv_path_ZIP
17666 if test -n "$ZIP"; then
17667   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17668 $as_echo "$ZIP" >&6; }
17669 else
17670   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17671 $as_echo "no" >&6; }
17672 fi
17673 
17674 
17675   test -n "$ZIP" && break
17676 done
17677 
17678     else
17679       # If it succeeded, then it was overridden by the user. We will use it
17680       # for the tool.
17681 
17682       # First remove it from the list of overridden variables, so we can test
17683       # for unknown variables in the end.
17684       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17685 
17686       # Check if the provided tool contains a complete path.
17687       tool_specified="$ZIP"
17688       tool_basename="${tool_specified##*/}"
17689       if test "x$tool_basename" = "x$tool_specified"; then
17690         # A command without a complete path is provided, search $PATH.
17691         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
17692 $as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
17693         # Extract the first word of "$tool_basename", so it can be a program name with args.
17694 set dummy $tool_basename; ac_word=$2
17695 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17696 $as_echo_n "checking for $ac_word... " >&6; }
17697 if ${ac_cv_path_ZIP+:} false; then :
17698   $as_echo_n "(cached) " >&6
17699 else
17700   case $ZIP in
17701   [\\/]* | ?:[\\/]*)
17702   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17703   ;;
17704   *)
17705   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17706 for as_dir in $PATH
17707 do
17708   IFS=$as_save_IFS
17709   test -z "$as_dir" && as_dir=.
17710     for ac_exec_ext in '' $ac_executable_extensions; do
17711   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17712     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17713     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17714     break 2
17715   fi
17716 done
17717   done
17718 IFS=$as_save_IFS
17719 
17720   ;;
17721 esac
17722 fi
17723 ZIP=$ac_cv_path_ZIP
17724 if test -n "$ZIP"; then
17725   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17726 $as_echo "$ZIP" >&6; }
17727 else
17728   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17729 $as_echo "no" >&6; }
17730 fi
17731 
17732 
17733         if test "x$ZIP" = x; then
17734           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17735         fi
17736       else
17737         # Otherwise we believe it is a complete path. Use it as it is.
17738         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
17739 $as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
17740         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
17741 $as_echo_n "checking for ZIP... " >&6; }
17742         if test ! -x "$tool_specified"; then
17743           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17744 $as_echo "not found" >&6; }
17745           as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17746         fi
17747         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17748 $as_echo "$tool_specified" >&6; }
17749       fi
17750     fi
17751   fi
17752 
17753 
17754 
17755   if test "x$ZIP" = x; then
17756     as_fn_error $? "Could not find required tool for ZIP" "$LINENO" 5
17757   fi
17758 
17759 
17760 
17761   # Non-required basic tools
17762 
17763 
17764 
17765   # Publish this variable in the help.
17766 
17767 
17768   if test "x$LDD" = x; then
17769     # The variable is not set by user, try to locate tool using the code snippet
17770     for ac_prog in ldd
17771 do
17772   # Extract the first word of "$ac_prog", so it can be a program name with args.
17773 set dummy $ac_prog; ac_word=$2
17774 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17775 $as_echo_n "checking for $ac_word... " >&6; }
17776 if ${ac_cv_path_LDD+:} false; then :
17777   $as_echo_n "(cached) " >&6
17778 else
17779   case $LDD in
17780   [\\/]* | ?:[\\/]*)
17781   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17782   ;;
17783   *)
17784   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17785 for as_dir in $PATH
17786 do
17787   IFS=$as_save_IFS
17788   test -z "$as_dir" && as_dir=.
17789     for ac_exec_ext in '' $ac_executable_extensions; do
17790   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17791     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17792     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17793     break 2
17794   fi
17795 done
17796   done
17797 IFS=$as_save_IFS
17798 
17799   ;;
17800 esac
17801 fi
17802 LDD=$ac_cv_path_LDD
17803 if test -n "$LDD"; then
17804   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17805 $as_echo "$LDD" >&6; }
17806 else
17807   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17808 $as_echo "no" >&6; }
17809 fi
17810 
17811 
17812   test -n "$LDD" && break
17813 done
17814 
17815   else
17816     # The variable is set, but is it from the command line or the environment?
17817 
17818     # Try to remove the string !LDD! from our list.
17819     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
17820     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17821       # If it failed, the variable was not from the command line. Ignore it,
17822       # but warn the user (except for BASH, which is always set by the calling BASH).
17823       if test "xLDD" != xBASH; then
17824         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
17825 $as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
17826       fi
17827       # Try to locate tool using the code snippet
17828       for ac_prog in ldd
17829 do
17830   # Extract the first word of "$ac_prog", so it can be a program name with args.
17831 set dummy $ac_prog; ac_word=$2
17832 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17833 $as_echo_n "checking for $ac_word... " >&6; }
17834 if ${ac_cv_path_LDD+:} false; then :
17835   $as_echo_n "(cached) " >&6
17836 else
17837   case $LDD in
17838   [\\/]* | ?:[\\/]*)
17839   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17840   ;;
17841   *)
17842   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17843 for as_dir in $PATH
17844 do
17845   IFS=$as_save_IFS
17846   test -z "$as_dir" && as_dir=.
17847     for ac_exec_ext in '' $ac_executable_extensions; do
17848   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17849     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17850     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17851     break 2
17852   fi
17853 done
17854   done
17855 IFS=$as_save_IFS
17856 
17857   ;;
17858 esac
17859 fi
17860 LDD=$ac_cv_path_LDD
17861 if test -n "$LDD"; then
17862   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17863 $as_echo "$LDD" >&6; }
17864 else
17865   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17866 $as_echo "no" >&6; }
17867 fi
17868 
17869 
17870   test -n "$LDD" && break
17871 done
17872 
17873     else
17874       # If it succeeded, then it was overridden by the user. We will use it
17875       # for the tool.
17876 
17877       # First remove it from the list of overridden variables, so we can test
17878       # for unknown variables in the end.
17879       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17880 
17881       # Check if the provided tool contains a complete path.
17882       tool_specified="$LDD"
17883       tool_basename="${tool_specified##*/}"
17884       if test "x$tool_basename" = "x$tool_specified"; then
17885         # A command without a complete path is provided, search $PATH.
17886         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
17887 $as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
17888         # Extract the first word of "$tool_basename", so it can be a program name with args.
17889 set dummy $tool_basename; ac_word=$2
17890 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17891 $as_echo_n "checking for $ac_word... " >&6; }
17892 if ${ac_cv_path_LDD+:} false; then :
17893   $as_echo_n "(cached) " >&6
17894 else
17895   case $LDD in
17896   [\\/]* | ?:[\\/]*)
17897   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17898   ;;
17899   *)
17900   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17901 for as_dir in $PATH
17902 do
17903   IFS=$as_save_IFS
17904   test -z "$as_dir" && as_dir=.
17905     for ac_exec_ext in '' $ac_executable_extensions; do
17906   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17907     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17908     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17909     break 2
17910   fi
17911 done
17912   done
17913 IFS=$as_save_IFS
17914 
17915   ;;
17916 esac
17917 fi
17918 LDD=$ac_cv_path_LDD
17919 if test -n "$LDD"; then
17920   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17921 $as_echo "$LDD" >&6; }
17922 else
17923   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17924 $as_echo "no" >&6; }
17925 fi
17926 
17927 
17928         if test "x$LDD" = x; then
17929           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17930         fi
17931       else
17932         # Otherwise we believe it is a complete path. Use it as it is.
17933         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
17934 $as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
17935         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
17936 $as_echo_n "checking for LDD... " >&6; }
17937         if test ! -x "$tool_specified"; then
17938           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17939 $as_echo "not found" >&6; }
17940           as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
17941         fi
17942         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17943 $as_echo "$tool_specified" >&6; }
17944       fi
17945     fi
17946   fi
17947 
17948 
17949   if test "x$LDD" = "x"; then
17950     # List shared lib dependencies is used for
17951     # debug output and checking for forbidden dependencies.
17952     # We can build without it.
17953     LDD="true"
17954   fi
17955 
17956 
17957   # Publish this variable in the help.
17958 
17959 
17960   if test "x$OTOOL" = x; then
17961     # The variable is not set by user, try to locate tool using the code snippet
17962     for ac_prog in otool
17963 do
17964   # Extract the first word of "$ac_prog", so it can be a program name with args.
17965 set dummy $ac_prog; ac_word=$2
17966 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17967 $as_echo_n "checking for $ac_word... " >&6; }
17968 if ${ac_cv_path_OTOOL+:} false; then :
17969   $as_echo_n "(cached) " >&6
17970 else
17971   case $OTOOL in
17972   [\\/]* | ?:[\\/]*)
17973   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
17974   ;;
17975   *)
17976   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17977 for as_dir in $PATH
17978 do
17979   IFS=$as_save_IFS
17980   test -z "$as_dir" && as_dir=.
17981     for ac_exec_ext in '' $ac_executable_extensions; do
17982   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17983     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
17984     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17985     break 2
17986   fi
17987 done
17988   done
17989 IFS=$as_save_IFS
17990 
17991   ;;
17992 esac
17993 fi
17994 OTOOL=$ac_cv_path_OTOOL
17995 if test -n "$OTOOL"; then
17996   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
17997 $as_echo "$OTOOL" >&6; }
17998 else
17999   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18000 $as_echo "no" >&6; }
18001 fi
18002 
18003 
18004   test -n "$OTOOL" && break
18005 done
18006 
18007   else
18008     # The variable is set, but is it from the command line or the environment?
18009 
18010     # Try to remove the string !OTOOL! from our list.
18011     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OTOOL!/}
18012     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18013       # If it failed, the variable was not from the command line. Ignore it,
18014       # but warn the user (except for BASH, which is always set by the calling BASH).
18015       if test "xOTOOL" != xBASH; then
18016         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&5
18017 $as_echo "$as_me: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&2;}
18018       fi
18019       # Try to locate tool using the code snippet
18020       for ac_prog in otool
18021 do
18022   # Extract the first word of "$ac_prog", so it can be a program name with args.
18023 set dummy $ac_prog; ac_word=$2
18024 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18025 $as_echo_n "checking for $ac_word... " >&6; }
18026 if ${ac_cv_path_OTOOL+:} false; then :
18027   $as_echo_n "(cached) " >&6
18028 else
18029   case $OTOOL in
18030   [\\/]* | ?:[\\/]*)
18031   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
18032   ;;
18033   *)
18034   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18035 for as_dir in $PATH
18036 do
18037   IFS=$as_save_IFS
18038   test -z "$as_dir" && as_dir=.
18039     for ac_exec_ext in '' $ac_executable_extensions; do
18040   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18041     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
18042     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18043     break 2
18044   fi
18045 done
18046   done
18047 IFS=$as_save_IFS
18048 
18049   ;;
18050 esac
18051 fi
18052 OTOOL=$ac_cv_path_OTOOL
18053 if test -n "$OTOOL"; then
18054   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
18055 $as_echo "$OTOOL" >&6; }
18056 else
18057   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18058 $as_echo "no" >&6; }
18059 fi
18060 
18061 
18062   test -n "$OTOOL" && break
18063 done
18064 
18065     else
18066       # If it succeeded, then it was overridden by the user. We will use it
18067       # for the tool.
18068 
18069       # First remove it from the list of overridden variables, so we can test
18070       # for unknown variables in the end.
18071       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18072 
18073       # Check if the provided tool contains a complete path.
18074       tool_specified="$OTOOL"
18075       tool_basename="${tool_specified##*/}"
18076       if test "x$tool_basename" = "x$tool_specified"; then
18077         # A command without a complete path is provided, search $PATH.
18078         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OTOOL=$tool_basename" >&5
18079 $as_echo "$as_me: Will search for user supplied tool OTOOL=$tool_basename" >&6;}
18080         # Extract the first word of "$tool_basename", so it can be a program name with args.
18081 set dummy $tool_basename; ac_word=$2
18082 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18083 $as_echo_n "checking for $ac_word... " >&6; }
18084 if ${ac_cv_path_OTOOL+:} false; then :
18085   $as_echo_n "(cached) " >&6
18086 else
18087   case $OTOOL in
18088   [\\/]* | ?:[\\/]*)
18089   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
18090   ;;
18091   *)
18092   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18093 for as_dir in $PATH
18094 do
18095   IFS=$as_save_IFS
18096   test -z "$as_dir" && as_dir=.
18097     for ac_exec_ext in '' $ac_executable_extensions; do
18098   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18099     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
18100     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18101     break 2
18102   fi
18103 done
18104   done
18105 IFS=$as_save_IFS
18106 
18107   ;;
18108 esac
18109 fi
18110 OTOOL=$ac_cv_path_OTOOL
18111 if test -n "$OTOOL"; then
18112   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
18113 $as_echo "$OTOOL" >&6; }
18114 else
18115   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18116 $as_echo "no" >&6; }
18117 fi
18118 
18119 
18120         if test "x$OTOOL" = x; then
18121           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18122         fi
18123       else
18124         # Otherwise we believe it is a complete path. Use it as it is.
18125         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OTOOL=$tool_specified" >&5
18126 $as_echo "$as_me: Will use user supplied tool OTOOL=$tool_specified" >&6;}
18127         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
18128 $as_echo_n "checking for OTOOL... " >&6; }
18129         if test ! -x "$tool_specified"; then
18130           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18131 $as_echo "not found" >&6; }
18132           as_fn_error $? "User supplied tool OTOOL=$tool_specified does not exist or is not executable" "$LINENO" 5
18133         fi
18134         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18135 $as_echo "$tool_specified" >&6; }
18136       fi
18137     fi
18138   fi
18139 
18140 
18141   if test "x$OTOOL" = "x"; then
18142     OTOOL="true"
18143   fi
18144 
18145 
18146   # Publish this variable in the help.
18147 
18148 
18149   if test "x$READELF" = x; then
18150     # The variable is not set by user, try to locate tool using the code snippet
18151     for ac_prog in greadelf readelf
18152 do
18153   # Extract the first word of "$ac_prog", so it can be a program name with args.
18154 set dummy $ac_prog; ac_word=$2
18155 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18156 $as_echo_n "checking for $ac_word... " >&6; }
18157 if ${ac_cv_path_READELF+:} false; then :
18158   $as_echo_n "(cached) " >&6
18159 else
18160   case $READELF in
18161   [\\/]* | ?:[\\/]*)
18162   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
18163   ;;
18164   *)
18165   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18166 for as_dir in $PATH
18167 do
18168   IFS=$as_save_IFS
18169   test -z "$as_dir" && as_dir=.
18170     for ac_exec_ext in '' $ac_executable_extensions; do
18171   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18172     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
18173     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18174     break 2
18175   fi
18176 done
18177   done
18178 IFS=$as_save_IFS
18179 
18180   ;;
18181 esac
18182 fi
18183 READELF=$ac_cv_path_READELF
18184 if test -n "$READELF"; then
18185   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
18186 $as_echo "$READELF" >&6; }
18187 else
18188   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18189 $as_echo "no" >&6; }
18190 fi
18191 
18192 
18193   test -n "$READELF" && break
18194 done
18195 
18196   else
18197     # The variable is set, but is it from the command line or the environment?
18198 
18199     # Try to remove the string !READELF! from our list.
18200     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
18201     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18202       # If it failed, the variable was not from the command line. Ignore it,
18203       # but warn the user (except for BASH, which is always set by the calling BASH).
18204       if test "xREADELF" != xBASH; then
18205         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
18206 $as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
18207       fi
18208       # Try to locate tool using the code snippet
18209       for ac_prog in greadelf readelf
18210 do
18211   # Extract the first word of "$ac_prog", so it can be a program name with args.
18212 set dummy $ac_prog; ac_word=$2
18213 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18214 $as_echo_n "checking for $ac_word... " >&6; }
18215 if ${ac_cv_path_READELF+:} false; then :
18216   $as_echo_n "(cached) " >&6
18217 else
18218   case $READELF in
18219   [\\/]* | ?:[\\/]*)
18220   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
18221   ;;
18222   *)
18223   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18224 for as_dir in $PATH
18225 do
18226   IFS=$as_save_IFS
18227   test -z "$as_dir" && as_dir=.
18228     for ac_exec_ext in '' $ac_executable_extensions; do
18229   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18230     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
18231     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18232     break 2
18233   fi
18234 done
18235   done
18236 IFS=$as_save_IFS
18237 
18238   ;;
18239 esac
18240 fi
18241 READELF=$ac_cv_path_READELF
18242 if test -n "$READELF"; then
18243   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
18244 $as_echo "$READELF" >&6; }
18245 else
18246   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18247 $as_echo "no" >&6; }
18248 fi
18249 
18250 
18251   test -n "$READELF" && break
18252 done
18253 
18254     else
18255       # If it succeeded, then it was overridden by the user. We will use it
18256       # for the tool.
18257 
18258       # First remove it from the list of overridden variables, so we can test
18259       # for unknown variables in the end.
18260       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18261 
18262       # Check if the provided tool contains a complete path.
18263       tool_specified="$READELF"
18264       tool_basename="${tool_specified##*/}"
18265       if test "x$tool_basename" = "x$tool_specified"; then
18266         # A command without a complete path is provided, search $PATH.
18267         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
18268 $as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
18269         # Extract the first word of "$tool_basename", so it can be a program name with args.
18270 set dummy $tool_basename; ac_word=$2
18271 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18272 $as_echo_n "checking for $ac_word... " >&6; }
18273 if ${ac_cv_path_READELF+:} false; then :
18274   $as_echo_n "(cached) " >&6
18275 else
18276   case $READELF in
18277   [\\/]* | ?:[\\/]*)
18278   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
18279   ;;
18280   *)
18281   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18282 for as_dir in $PATH
18283 do
18284   IFS=$as_save_IFS
18285   test -z "$as_dir" && as_dir=.
18286     for ac_exec_ext in '' $ac_executable_extensions; do
18287   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18288     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
18289     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18290     break 2
18291   fi
18292 done
18293   done
18294 IFS=$as_save_IFS
18295 
18296   ;;
18297 esac
18298 fi
18299 READELF=$ac_cv_path_READELF
18300 if test -n "$READELF"; then
18301   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
18302 $as_echo "$READELF" >&6; }
18303 else
18304   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18305 $as_echo "no" >&6; }
18306 fi
18307 
18308 
18309         if test "x$READELF" = x; then
18310           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18311         fi
18312       else
18313         # Otherwise we believe it is a complete path. Use it as it is.
18314         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
18315 $as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
18316         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
18317 $as_echo_n "checking for READELF... " >&6; }
18318         if test ! -x "$tool_specified"; then
18319           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18320 $as_echo "not found" >&6; }
18321           as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
18322         fi
18323         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18324 $as_echo "$tool_specified" >&6; }
18325       fi
18326     fi
18327   fi
18328 
18329 
18330 
18331 
18332   # Publish this variable in the help.
18333 
18334 
18335   if test "x$HG" = x; then
18336     # The variable is not set by user, try to locate tool using the code snippet
18337     for ac_prog in hg
18338 do
18339   # Extract the first word of "$ac_prog", so it can be a program name with args.
18340 set dummy $ac_prog; ac_word=$2
18341 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18342 $as_echo_n "checking for $ac_word... " >&6; }
18343 if ${ac_cv_path_HG+:} false; then :
18344   $as_echo_n "(cached) " >&6
18345 else
18346   case $HG in
18347   [\\/]* | ?:[\\/]*)
18348   ac_cv_path_HG="$HG" # Let the user override the test with a path.
18349   ;;
18350   *)
18351   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18352 for as_dir in $PATH
18353 do
18354   IFS=$as_save_IFS
18355   test -z "$as_dir" && as_dir=.
18356     for ac_exec_ext in '' $ac_executable_extensions; do
18357   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18358     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18359     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18360     break 2
18361   fi
18362 done
18363   done
18364 IFS=$as_save_IFS
18365 
18366   ;;
18367 esac
18368 fi
18369 HG=$ac_cv_path_HG
18370 if test -n "$HG"; then
18371   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18372 $as_echo "$HG" >&6; }
18373 else
18374   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18375 $as_echo "no" >&6; }
18376 fi
18377 
18378 
18379   test -n "$HG" && break
18380 done
18381 
18382   else
18383     # The variable is set, but is it from the command line or the environment?
18384 
18385     # Try to remove the string !HG! from our list.
18386     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
18387     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18388       # If it failed, the variable was not from the command line. Ignore it,
18389       # but warn the user (except for BASH, which is always set by the calling BASH).
18390       if test "xHG" != xBASH; then
18391         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
18392 $as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
18393       fi
18394       # Try to locate tool using the code snippet
18395       for ac_prog in hg
18396 do
18397   # Extract the first word of "$ac_prog", so it can be a program name with args.
18398 set dummy $ac_prog; ac_word=$2
18399 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18400 $as_echo_n "checking for $ac_word... " >&6; }
18401 if ${ac_cv_path_HG+:} false; then :
18402   $as_echo_n "(cached) " >&6
18403 else
18404   case $HG in
18405   [\\/]* | ?:[\\/]*)
18406   ac_cv_path_HG="$HG" # Let the user override the test with a path.
18407   ;;
18408   *)
18409   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18410 for as_dir in $PATH
18411 do
18412   IFS=$as_save_IFS
18413   test -z "$as_dir" && as_dir=.
18414     for ac_exec_ext in '' $ac_executable_extensions; do
18415   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18416     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18417     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18418     break 2
18419   fi
18420 done
18421   done
18422 IFS=$as_save_IFS
18423 
18424   ;;
18425 esac
18426 fi
18427 HG=$ac_cv_path_HG
18428 if test -n "$HG"; then
18429   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18430 $as_echo "$HG" >&6; }
18431 else
18432   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18433 $as_echo "no" >&6; }
18434 fi
18435 
18436 
18437   test -n "$HG" && break
18438 done
18439 
18440     else
18441       # If it succeeded, then it was overridden by the user. We will use it
18442       # for the tool.
18443 
18444       # First remove it from the list of overridden variables, so we can test
18445       # for unknown variables in the end.
18446       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18447 
18448       # Check if the provided tool contains a complete path.
18449       tool_specified="$HG"
18450       tool_basename="${tool_specified##*/}"
18451       if test "x$tool_basename" = "x$tool_specified"; then
18452         # A command without a complete path is provided, search $PATH.
18453         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
18454 $as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
18455         # Extract the first word of "$tool_basename", so it can be a program name with args.
18456 set dummy $tool_basename; ac_word=$2
18457 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18458 $as_echo_n "checking for $ac_word... " >&6; }
18459 if ${ac_cv_path_HG+:} false; then :
18460   $as_echo_n "(cached) " >&6
18461 else
18462   case $HG in
18463   [\\/]* | ?:[\\/]*)
18464   ac_cv_path_HG="$HG" # Let the user override the test with a path.
18465   ;;
18466   *)
18467   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18468 for as_dir in $PATH
18469 do
18470   IFS=$as_save_IFS
18471   test -z "$as_dir" && as_dir=.
18472     for ac_exec_ext in '' $ac_executable_extensions; do
18473   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18474     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18475     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18476     break 2
18477   fi
18478 done
18479   done
18480 IFS=$as_save_IFS
18481 
18482   ;;
18483 esac
18484 fi
18485 HG=$ac_cv_path_HG
18486 if test -n "$HG"; then
18487   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18488 $as_echo "$HG" >&6; }
18489 else
18490   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18491 $as_echo "no" >&6; }
18492 fi
18493 
18494 
18495         if test "x$HG" = x; then
18496           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18497         fi
18498       else
18499         # Otherwise we believe it is a complete path. Use it as it is.
18500         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
18501 $as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
18502         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
18503 $as_echo_n "checking for HG... " >&6; }
18504         if test ! -x "$tool_specified"; then
18505           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18506 $as_echo "not found" >&6; }
18507           as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
18508         fi
18509         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18510 $as_echo "$tool_specified" >&6; }
18511       fi
18512     fi
18513   fi
18514 
18515 
18516 
18517 
18518   # Publish this variable in the help.
18519 
18520 
18521   if test "x$STAT" = x; then
18522     # The variable is not set by user, try to locate tool using the code snippet
18523     for ac_prog in stat
18524 do
18525   # Extract the first word of "$ac_prog", so it can be a program name with args.
18526 set dummy $ac_prog; ac_word=$2
18527 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18528 $as_echo_n "checking for $ac_word... " >&6; }
18529 if ${ac_cv_path_STAT+:} false; then :
18530   $as_echo_n "(cached) " >&6
18531 else
18532   case $STAT in
18533   [\\/]* | ?:[\\/]*)
18534   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18535   ;;
18536   *)
18537   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18538 for as_dir in $PATH
18539 do
18540   IFS=$as_save_IFS
18541   test -z "$as_dir" && as_dir=.
18542     for ac_exec_ext in '' $ac_executable_extensions; do
18543   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18544     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18545     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18546     break 2
18547   fi
18548 done
18549   done
18550 IFS=$as_save_IFS
18551 
18552   ;;
18553 esac
18554 fi
18555 STAT=$ac_cv_path_STAT
18556 if test -n "$STAT"; then
18557   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18558 $as_echo "$STAT" >&6; }
18559 else
18560   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18561 $as_echo "no" >&6; }
18562 fi
18563 
18564 
18565   test -n "$STAT" && break
18566 done
18567 
18568   else
18569     # The variable is set, but is it from the command line or the environment?
18570 
18571     # Try to remove the string !STAT! from our list.
18572     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
18573     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18574       # If it failed, the variable was not from the command line. Ignore it,
18575       # but warn the user (except for BASH, which is always set by the calling BASH).
18576       if test "xSTAT" != xBASH; then
18577         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
18578 $as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
18579       fi
18580       # Try to locate tool using the code snippet
18581       for ac_prog in stat
18582 do
18583   # Extract the first word of "$ac_prog", so it can be a program name with args.
18584 set dummy $ac_prog; ac_word=$2
18585 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18586 $as_echo_n "checking for $ac_word... " >&6; }
18587 if ${ac_cv_path_STAT+:} false; then :
18588   $as_echo_n "(cached) " >&6
18589 else
18590   case $STAT in
18591   [\\/]* | ?:[\\/]*)
18592   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18593   ;;
18594   *)
18595   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18596 for as_dir in $PATH
18597 do
18598   IFS=$as_save_IFS
18599   test -z "$as_dir" && as_dir=.
18600     for ac_exec_ext in '' $ac_executable_extensions; do
18601   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18602     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18603     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18604     break 2
18605   fi
18606 done
18607   done
18608 IFS=$as_save_IFS
18609 
18610   ;;
18611 esac
18612 fi
18613 STAT=$ac_cv_path_STAT
18614 if test -n "$STAT"; then
18615   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18616 $as_echo "$STAT" >&6; }
18617 else
18618   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18619 $as_echo "no" >&6; }
18620 fi
18621 
18622 
18623   test -n "$STAT" && break
18624 done
18625 
18626     else
18627       # If it succeeded, then it was overridden by the user. We will use it
18628       # for the tool.
18629 
18630       # First remove it from the list of overridden variables, so we can test
18631       # for unknown variables in the end.
18632       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18633 
18634       # Check if the provided tool contains a complete path.
18635       tool_specified="$STAT"
18636       tool_basename="${tool_specified##*/}"
18637       if test "x$tool_basename" = "x$tool_specified"; then
18638         # A command without a complete path is provided, search $PATH.
18639         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
18640 $as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
18641         # Extract the first word of "$tool_basename", so it can be a program name with args.
18642 set dummy $tool_basename; ac_word=$2
18643 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18644 $as_echo_n "checking for $ac_word... " >&6; }
18645 if ${ac_cv_path_STAT+:} false; then :
18646   $as_echo_n "(cached) " >&6
18647 else
18648   case $STAT in
18649   [\\/]* | ?:[\\/]*)
18650   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18651   ;;
18652   *)
18653   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18654 for as_dir in $PATH
18655 do
18656   IFS=$as_save_IFS
18657   test -z "$as_dir" && as_dir=.
18658     for ac_exec_ext in '' $ac_executable_extensions; do
18659   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18660     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18661     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18662     break 2
18663   fi
18664 done
18665   done
18666 IFS=$as_save_IFS
18667 
18668   ;;
18669 esac
18670 fi
18671 STAT=$ac_cv_path_STAT
18672 if test -n "$STAT"; then
18673   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18674 $as_echo "$STAT" >&6; }
18675 else
18676   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18677 $as_echo "no" >&6; }
18678 fi
18679 
18680 
18681         if test "x$STAT" = x; then
18682           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18683         fi
18684       else
18685         # Otherwise we believe it is a complete path. Use it as it is.
18686         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
18687 $as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
18688         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
18689 $as_echo_n "checking for STAT... " >&6; }
18690         if test ! -x "$tool_specified"; then
18691           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18692 $as_echo "not found" >&6; }
18693           as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
18694         fi
18695         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18696 $as_echo "$tool_specified" >&6; }
18697       fi
18698     fi
18699   fi
18700 
18701 
18702 
18703 
18704   # Publish this variable in the help.
18705 
18706 
18707   if test "x$TIME" = x; then
18708     # The variable is not set by user, try to locate tool using the code snippet
18709     for ac_prog in time
18710 do
18711   # Extract the first word of "$ac_prog", so it can be a program name with args.
18712 set dummy $ac_prog; ac_word=$2
18713 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18714 $as_echo_n "checking for $ac_word... " >&6; }
18715 if ${ac_cv_path_TIME+:} false; then :
18716   $as_echo_n "(cached) " >&6
18717 else
18718   case $TIME in
18719   [\\/]* | ?:[\\/]*)
18720   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18721   ;;
18722   *)
18723   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18724 for as_dir in $PATH
18725 do
18726   IFS=$as_save_IFS
18727   test -z "$as_dir" && as_dir=.
18728     for ac_exec_ext in '' $ac_executable_extensions; do
18729   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18730     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18731     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18732     break 2
18733   fi
18734 done
18735   done
18736 IFS=$as_save_IFS
18737 
18738   ;;
18739 esac
18740 fi
18741 TIME=$ac_cv_path_TIME
18742 if test -n "$TIME"; then
18743   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18744 $as_echo "$TIME" >&6; }
18745 else
18746   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18747 $as_echo "no" >&6; }
18748 fi
18749 
18750 
18751   test -n "$TIME" && break
18752 done
18753 
18754   else
18755     # The variable is set, but is it from the command line or the environment?
18756 
18757     # Try to remove the string !TIME! from our list.
18758     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
18759     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18760       # If it failed, the variable was not from the command line. Ignore it,
18761       # but warn the user (except for BASH, which is always set by the calling BASH).
18762       if test "xTIME" != xBASH; then
18763         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
18764 $as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
18765       fi
18766       # Try to locate tool using the code snippet
18767       for ac_prog in time
18768 do
18769   # Extract the first word of "$ac_prog", so it can be a program name with args.
18770 set dummy $ac_prog; ac_word=$2
18771 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18772 $as_echo_n "checking for $ac_word... " >&6; }
18773 if ${ac_cv_path_TIME+:} false; then :
18774   $as_echo_n "(cached) " >&6
18775 else
18776   case $TIME in
18777   [\\/]* | ?:[\\/]*)
18778   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18779   ;;
18780   *)
18781   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18782 for as_dir in $PATH
18783 do
18784   IFS=$as_save_IFS
18785   test -z "$as_dir" && as_dir=.
18786     for ac_exec_ext in '' $ac_executable_extensions; do
18787   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18788     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18789     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18790     break 2
18791   fi
18792 done
18793   done
18794 IFS=$as_save_IFS
18795 
18796   ;;
18797 esac
18798 fi
18799 TIME=$ac_cv_path_TIME
18800 if test -n "$TIME"; then
18801   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18802 $as_echo "$TIME" >&6; }
18803 else
18804   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18805 $as_echo "no" >&6; }
18806 fi
18807 
18808 
18809   test -n "$TIME" && break
18810 done
18811 
18812     else
18813       # If it succeeded, then it was overridden by the user. We will use it
18814       # for the tool.
18815 
18816       # First remove it from the list of overridden variables, so we can test
18817       # for unknown variables in the end.
18818       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18819 
18820       # Check if the provided tool contains a complete path.
18821       tool_specified="$TIME"
18822       tool_basename="${tool_specified##*/}"
18823       if test "x$tool_basename" = "x$tool_specified"; then
18824         # A command without a complete path is provided, search $PATH.
18825         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
18826 $as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
18827         # Extract the first word of "$tool_basename", so it can be a program name with args.
18828 set dummy $tool_basename; ac_word=$2
18829 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18830 $as_echo_n "checking for $ac_word... " >&6; }
18831 if ${ac_cv_path_TIME+:} false; then :
18832   $as_echo_n "(cached) " >&6
18833 else
18834   case $TIME in
18835   [\\/]* | ?:[\\/]*)
18836   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18837   ;;
18838   *)
18839   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18840 for as_dir in $PATH
18841 do
18842   IFS=$as_save_IFS
18843   test -z "$as_dir" && as_dir=.
18844     for ac_exec_ext in '' $ac_executable_extensions; do
18845   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18846     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18847     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18848     break 2
18849   fi
18850 done
18851   done
18852 IFS=$as_save_IFS
18853 
18854   ;;
18855 esac
18856 fi
18857 TIME=$ac_cv_path_TIME
18858 if test -n "$TIME"; then
18859   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18860 $as_echo "$TIME" >&6; }
18861 else
18862   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18863 $as_echo "no" >&6; }
18864 fi
18865 
18866 
18867         if test "x$TIME" = x; then
18868           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18869         fi
18870       else
18871         # Otherwise we believe it is a complete path. Use it as it is.
18872         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
18873 $as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
18874         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
18875 $as_echo_n "checking for TIME... " >&6; }
18876         if test ! -x "$tool_specified"; then
18877           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18878 $as_echo "not found" >&6; }
18879           as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
18880         fi
18881         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18882 $as_echo "$tool_specified" >&6; }
18883       fi
18884     fi
18885   fi
18886 
18887 
18888   # Check if it's GNU time
18889   IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
18890   if test "x$IS_GNU_TIME" != x; then
18891     IS_GNU_TIME=yes
18892   else
18893     IS_GNU_TIME=no
18894   fi
18895 
18896 
18897   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
18898 
18899 
18900 
18901   # Publish this variable in the help.
18902 
18903 
18904   if test "x$DSYMUTIL" = x; then
18905     # The variable is not set by user, try to locate tool using the code snippet
18906     for ac_prog in dsymutil
18907 do
18908   # Extract the first word of "$ac_prog", so it can be a program name with args.
18909 set dummy $ac_prog; ac_word=$2
18910 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18911 $as_echo_n "checking for $ac_word... " >&6; }
18912 if ${ac_cv_path_DSYMUTIL+:} false; then :
18913   $as_echo_n "(cached) " >&6
18914 else
18915   case $DSYMUTIL in
18916   [\\/]* | ?:[\\/]*)
18917   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18918   ;;
18919   *)
18920   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18921 for as_dir in $PATH
18922 do
18923   IFS=$as_save_IFS
18924   test -z "$as_dir" && as_dir=.
18925     for ac_exec_ext in '' $ac_executable_extensions; do
18926   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18927     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18928     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18929     break 2
18930   fi
18931 done
18932   done
18933 IFS=$as_save_IFS
18934 
18935   ;;
18936 esac
18937 fi
18938 DSYMUTIL=$ac_cv_path_DSYMUTIL
18939 if test -n "$DSYMUTIL"; then
18940   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18941 $as_echo "$DSYMUTIL" >&6; }
18942 else
18943   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18944 $as_echo "no" >&6; }
18945 fi
18946 
18947 
18948   test -n "$DSYMUTIL" && break
18949 done
18950 
18951   else
18952     # The variable is set, but is it from the command line or the environment?
18953 
18954     # Try to remove the string !DSYMUTIL! from our list.
18955     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
18956     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18957       # If it failed, the variable was not from the command line. Ignore it,
18958       # but warn the user (except for BASH, which is always set by the calling BASH).
18959       if test "xDSYMUTIL" != xBASH; then
18960         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
18961 $as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
18962       fi
18963       # Try to locate tool using the code snippet
18964       for ac_prog in dsymutil
18965 do
18966   # Extract the first word of "$ac_prog", so it can be a program name with args.
18967 set dummy $ac_prog; ac_word=$2
18968 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18969 $as_echo_n "checking for $ac_word... " >&6; }
18970 if ${ac_cv_path_DSYMUTIL+:} false; then :
18971   $as_echo_n "(cached) " >&6
18972 else
18973   case $DSYMUTIL in
18974   [\\/]* | ?:[\\/]*)
18975   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18976   ;;
18977   *)
18978   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18979 for as_dir in $PATH
18980 do
18981   IFS=$as_save_IFS
18982   test -z "$as_dir" && as_dir=.
18983     for ac_exec_ext in '' $ac_executable_extensions; do
18984   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18985     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18986     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18987     break 2
18988   fi
18989 done
18990   done
18991 IFS=$as_save_IFS
18992 
18993   ;;
18994 esac
18995 fi
18996 DSYMUTIL=$ac_cv_path_DSYMUTIL
18997 if test -n "$DSYMUTIL"; then
18998   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18999 $as_echo "$DSYMUTIL" >&6; }
19000 else
19001   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19002 $as_echo "no" >&6; }
19003 fi
19004 
19005 
19006   test -n "$DSYMUTIL" && break
19007 done
19008 
19009     else
19010       # If it succeeded, then it was overridden by the user. We will use it
19011       # for the tool.
19012 
19013       # First remove it from the list of overridden variables, so we can test
19014       # for unknown variables in the end.
19015       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19016 
19017       # Check if the provided tool contains a complete path.
19018       tool_specified="$DSYMUTIL"
19019       tool_basename="${tool_specified##*/}"
19020       if test "x$tool_basename" = "x$tool_specified"; then
19021         # A command without a complete path is provided, search $PATH.
19022         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
19023 $as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
19024         # Extract the first word of "$tool_basename", so it can be a program name with args.
19025 set dummy $tool_basename; ac_word=$2
19026 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19027 $as_echo_n "checking for $ac_word... " >&6; }
19028 if ${ac_cv_path_DSYMUTIL+:} false; then :
19029   $as_echo_n "(cached) " >&6
19030 else
19031   case $DSYMUTIL in
19032   [\\/]* | ?:[\\/]*)
19033   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
19034   ;;
19035   *)
19036   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19037 for as_dir in $PATH
19038 do
19039   IFS=$as_save_IFS
19040   test -z "$as_dir" && as_dir=.
19041     for ac_exec_ext in '' $ac_executable_extensions; do
19042   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19043     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
19044     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19045     break 2
19046   fi
19047 done
19048   done
19049 IFS=$as_save_IFS
19050 
19051   ;;
19052 esac
19053 fi
19054 DSYMUTIL=$ac_cv_path_DSYMUTIL
19055 if test -n "$DSYMUTIL"; then
19056   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
19057 $as_echo "$DSYMUTIL" >&6; }
19058 else
19059   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19060 $as_echo "no" >&6; }
19061 fi
19062 
19063 
19064         if test "x$DSYMUTIL" = x; then
19065           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19066         fi
19067       else
19068         # Otherwise we believe it is a complete path. Use it as it is.
19069         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
19070 $as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
19071         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
19072 $as_echo_n "checking for DSYMUTIL... " >&6; }
19073         if test ! -x "$tool_specified"; then
19074           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19075 $as_echo "not found" >&6; }
19076           as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
19077         fi
19078         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19079 $as_echo "$tool_specified" >&6; }
19080       fi
19081     fi
19082   fi
19083 
19084 
19085 
19086   if test "x$DSYMUTIL" = x; then
19087     as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
19088   fi
19089 
19090 
19091 
19092 
19093 
19094   # Publish this variable in the help.
19095 
19096 
19097   if test "x$XATTR" = x; then
19098     # The variable is not set by user, try to locate tool using the code snippet
19099     for ac_prog in xattr
19100 do
19101   # Extract the first word of "$ac_prog", so it can be a program name with args.
19102 set dummy $ac_prog; ac_word=$2
19103 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19104 $as_echo_n "checking for $ac_word... " >&6; }
19105 if ${ac_cv_path_XATTR+:} false; then :
19106   $as_echo_n "(cached) " >&6
19107 else
19108   case $XATTR in
19109   [\\/]* | ?:[\\/]*)
19110   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19111   ;;
19112   *)
19113   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19114 for as_dir in $PATH
19115 do
19116   IFS=$as_save_IFS
19117   test -z "$as_dir" && as_dir=.
19118     for ac_exec_ext in '' $ac_executable_extensions; do
19119   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19120     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19121     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19122     break 2
19123   fi
19124 done
19125   done
19126 IFS=$as_save_IFS
19127 
19128   ;;
19129 esac
19130 fi
19131 XATTR=$ac_cv_path_XATTR
19132 if test -n "$XATTR"; then
19133   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19134 $as_echo "$XATTR" >&6; }
19135 else
19136   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19137 $as_echo "no" >&6; }
19138 fi
19139 
19140 
19141   test -n "$XATTR" && break
19142 done
19143 
19144   else
19145     # The variable is set, but is it from the command line or the environment?
19146 
19147     # Try to remove the string !XATTR! from our list.
19148     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
19149     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19150       # If it failed, the variable was not from the command line. Ignore it,
19151       # but warn the user (except for BASH, which is always set by the calling BASH).
19152       if test "xXATTR" != xBASH; then
19153         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
19154 $as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
19155       fi
19156       # Try to locate tool using the code snippet
19157       for ac_prog in xattr
19158 do
19159   # Extract the first word of "$ac_prog", so it can be a program name with args.
19160 set dummy $ac_prog; ac_word=$2
19161 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19162 $as_echo_n "checking for $ac_word... " >&6; }
19163 if ${ac_cv_path_XATTR+:} false; then :
19164   $as_echo_n "(cached) " >&6
19165 else
19166   case $XATTR in
19167   [\\/]* | ?:[\\/]*)
19168   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19169   ;;
19170   *)
19171   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19172 for as_dir in $PATH
19173 do
19174   IFS=$as_save_IFS
19175   test -z "$as_dir" && as_dir=.
19176     for ac_exec_ext in '' $ac_executable_extensions; do
19177   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19178     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19179     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19180     break 2
19181   fi
19182 done
19183   done
19184 IFS=$as_save_IFS
19185 
19186   ;;
19187 esac
19188 fi
19189 XATTR=$ac_cv_path_XATTR
19190 if test -n "$XATTR"; then
19191   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19192 $as_echo "$XATTR" >&6; }
19193 else
19194   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19195 $as_echo "no" >&6; }
19196 fi
19197 
19198 
19199   test -n "$XATTR" && break
19200 done
19201 
19202     else
19203       # If it succeeded, then it was overridden by the user. We will use it
19204       # for the tool.
19205 
19206       # First remove it from the list of overridden variables, so we can test
19207       # for unknown variables in the end.
19208       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19209 
19210       # Check if the provided tool contains a complete path.
19211       tool_specified="$XATTR"
19212       tool_basename="${tool_specified##*/}"
19213       if test "x$tool_basename" = "x$tool_specified"; then
19214         # A command without a complete path is provided, search $PATH.
19215         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
19216 $as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
19217         # Extract the first word of "$tool_basename", so it can be a program name with args.
19218 set dummy $tool_basename; ac_word=$2
19219 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19220 $as_echo_n "checking for $ac_word... " >&6; }
19221 if ${ac_cv_path_XATTR+:} false; then :
19222   $as_echo_n "(cached) " >&6
19223 else
19224   case $XATTR in
19225   [\\/]* | ?:[\\/]*)
19226   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19227   ;;
19228   *)
19229   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19230 for as_dir in $PATH
19231 do
19232   IFS=$as_save_IFS
19233   test -z "$as_dir" && as_dir=.
19234     for ac_exec_ext in '' $ac_executable_extensions; do
19235   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19236     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19237     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19238     break 2
19239   fi
19240 done
19241   done
19242 IFS=$as_save_IFS
19243 
19244   ;;
19245 esac
19246 fi
19247 XATTR=$ac_cv_path_XATTR
19248 if test -n "$XATTR"; then
19249   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19250 $as_echo "$XATTR" >&6; }
19251 else
19252   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19253 $as_echo "no" >&6; }
19254 fi
19255 
19256 
19257         if test "x$XATTR" = x; then
19258           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19259         fi
19260       else
19261         # Otherwise we believe it is a complete path. Use it as it is.
19262         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
19263 $as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
19264         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
19265 $as_echo_n "checking for XATTR... " >&6; }
19266         if test ! -x "$tool_specified"; then
19267           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19268 $as_echo "not found" >&6; }
19269           as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
19270         fi
19271         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19272 $as_echo "$tool_specified" >&6; }
19273       fi
19274     fi
19275   fi
19276 
19277 
19278 
19279   if test "x$XATTR" = x; then
19280     as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
19281   fi
19282 
19283 
19284 
19285 
19286   # Publish this variable in the help.
19287 
19288 
19289   if test "x$CODESIGN" = x; then
19290     # The variable is not set by user, try to locate tool using the code snippet
19291     for ac_prog in codesign
19292 do
19293   # Extract the first word of "$ac_prog", so it can be a program name with args.
19294 set dummy $ac_prog; ac_word=$2
19295 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19296 $as_echo_n "checking for $ac_word... " >&6; }
19297 if ${ac_cv_path_CODESIGN+:} false; then :
19298   $as_echo_n "(cached) " >&6
19299 else
19300   case $CODESIGN in
19301   [\\/]* | ?:[\\/]*)
19302   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19303   ;;
19304   *)
19305   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19306 for as_dir in $PATH
19307 do
19308   IFS=$as_save_IFS
19309   test -z "$as_dir" && as_dir=.
19310     for ac_exec_ext in '' $ac_executable_extensions; do
19311   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19312     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19313     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19314     break 2
19315   fi
19316 done
19317   done
19318 IFS=$as_save_IFS
19319 
19320   ;;
19321 esac
19322 fi
19323 CODESIGN=$ac_cv_path_CODESIGN
19324 if test -n "$CODESIGN"; then
19325   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19326 $as_echo "$CODESIGN" >&6; }
19327 else
19328   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19329 $as_echo "no" >&6; }
19330 fi
19331 
19332 
19333   test -n "$CODESIGN" && break
19334 done
19335 
19336   else
19337     # The variable is set, but is it from the command line or the environment?
19338 
19339     # Try to remove the string !CODESIGN! from our list.
19340     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
19341     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19342       # If it failed, the variable was not from the command line. Ignore it,
19343       # but warn the user (except for BASH, which is always set by the calling BASH).
19344       if test "xCODESIGN" != xBASH; then
19345         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
19346 $as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
19347       fi
19348       # Try to locate tool using the code snippet
19349       for ac_prog in codesign
19350 do
19351   # Extract the first word of "$ac_prog", so it can be a program name with args.
19352 set dummy $ac_prog; ac_word=$2
19353 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19354 $as_echo_n "checking for $ac_word... " >&6; }
19355 if ${ac_cv_path_CODESIGN+:} false; then :
19356   $as_echo_n "(cached) " >&6
19357 else
19358   case $CODESIGN in
19359   [\\/]* | ?:[\\/]*)
19360   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19361   ;;
19362   *)
19363   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19364 for as_dir in $PATH
19365 do
19366   IFS=$as_save_IFS
19367   test -z "$as_dir" && as_dir=.
19368     for ac_exec_ext in '' $ac_executable_extensions; do
19369   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19370     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19371     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19372     break 2
19373   fi
19374 done
19375   done
19376 IFS=$as_save_IFS
19377 
19378   ;;
19379 esac
19380 fi
19381 CODESIGN=$ac_cv_path_CODESIGN
19382 if test -n "$CODESIGN"; then
19383   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19384 $as_echo "$CODESIGN" >&6; }
19385 else
19386   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19387 $as_echo "no" >&6; }
19388 fi
19389 
19390 
19391   test -n "$CODESIGN" && break
19392 done
19393 
19394     else
19395       # If it succeeded, then it was overridden by the user. We will use it
19396       # for the tool.
19397 
19398       # First remove it from the list of overridden variables, so we can test
19399       # for unknown variables in the end.
19400       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19401 
19402       # Check if the provided tool contains a complete path.
19403       tool_specified="$CODESIGN"
19404       tool_basename="${tool_specified##*/}"
19405       if test "x$tool_basename" = "x$tool_specified"; then
19406         # A command without a complete path is provided, search $PATH.
19407         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
19408 $as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
19409         # Extract the first word of "$tool_basename", so it can be a program name with args.
19410 set dummy $tool_basename; ac_word=$2
19411 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19412 $as_echo_n "checking for $ac_word... " >&6; }
19413 if ${ac_cv_path_CODESIGN+:} false; then :
19414   $as_echo_n "(cached) " >&6
19415 else
19416   case $CODESIGN in
19417   [\\/]* | ?:[\\/]*)
19418   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19419   ;;
19420   *)
19421   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19422 for as_dir in $PATH
19423 do
19424   IFS=$as_save_IFS
19425   test -z "$as_dir" && as_dir=.
19426     for ac_exec_ext in '' $ac_executable_extensions; do
19427   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19428     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19429     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19430     break 2
19431   fi
19432 done
19433   done
19434 IFS=$as_save_IFS
19435 
19436   ;;
19437 esac
19438 fi
19439 CODESIGN=$ac_cv_path_CODESIGN
19440 if test -n "$CODESIGN"; then
19441   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19442 $as_echo "$CODESIGN" >&6; }
19443 else
19444   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19445 $as_echo "no" >&6; }
19446 fi
19447 
19448 
19449         if test "x$CODESIGN" = x; then
19450           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19451         fi
19452       else
19453         # Otherwise we believe it is a complete path. Use it as it is.
19454         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
19455 $as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
19456         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
19457 $as_echo_n "checking for CODESIGN... " >&6; }
19458         if test ! -x "$tool_specified"; then
19459           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19460 $as_echo "not found" >&6; }
19461           as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
19462         fi
19463         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19464 $as_echo "$tool_specified" >&6; }
19465       fi
19466     fi
19467   fi
19468 
19469 
19470     if test "x$CODESIGN" != "x"; then
19471       # Verify that the openjdk_codesign certificate is present
19472       { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
19473 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
19474       rm -f codesign-testfile
19475       touch codesign-testfile
19476       codesign -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
19477       rm -f codesign-testfile
19478       if test "x$CODESIGN" = x; then
19479         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19480 $as_echo "no" >&6; }
19481       else
19482         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19483 $as_echo "yes" >&6; }
19484       fi
19485     fi
19486   fi
19487 
19488 
19489   # Test if bash supports pipefail.
19490   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports pipefail" >&5
19491 $as_echo_n "checking if bash supports pipefail... " >&6; }
19492   if ${BASH} -c 'set -o pipefail'; then
19493     BASH_ARGS="$BASH_ARGS -o pipefail"
19494     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19495 $as_echo "yes" >&6; }
19496   else
19497     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19498 $as_echo "no" >&6; }
19499   fi
19500 
19501   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports errexit (-e)" >&5
19502 $as_echo_n "checking if bash supports errexit (-e)... " >&6; }
19503   if ${BASH} -e -c 'true'; then
19504     BASH_ARGS="$BASH_ARGS -e"
19505     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19506 $as_echo "yes" >&6; }
19507   else
19508     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19509 $as_echo "no" >&6; }
19510   fi
19511 
19512 
19513 
19514 
19515 # Check if pkg-config is available.
19516 
19517 
19518 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
19519         if test -n "$ac_tool_prefix"; then
19520   # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
19521 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
19522 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19523 $as_echo_n "checking for $ac_word... " >&6; }
19524 if ${ac_cv_path_PKG_CONFIG+:} false; then :
19525   $as_echo_n "(cached) " >&6
19526 else
19527   case $PKG_CONFIG in
19528   [\\/]* | ?:[\\/]*)
19529   ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
19530   ;;
19531   *)
19532   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19533 for as_dir in $PATH
19534 do
19535   IFS=$as_save_IFS
19536   test -z "$as_dir" && as_dir=.
19537     for ac_exec_ext in '' $ac_executable_extensions; do
19538   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19539     ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
19540     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19541     break 2
19542   fi
19543 done
19544   done
19545 IFS=$as_save_IFS
19546 
19547   ;;
19548 esac
19549 fi
19550 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
19551 if test -n "$PKG_CONFIG"; then
19552   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
19553 $as_echo "$PKG_CONFIG" >&6; }
19554 else
19555   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19556 $as_echo "no" >&6; }
19557 fi
19558 
19559 
19560 fi
19561 if test -z "$ac_cv_path_PKG_CONFIG"; then
19562   ac_pt_PKG_CONFIG=$PKG_CONFIG
19563   # Extract the first word of "pkg-config", so it can be a program name with args.
19564 set dummy pkg-config; ac_word=$2
19565 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19566 $as_echo_n "checking for $ac_word... " >&6; }
19567 if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
19568   $as_echo_n "(cached) " >&6
19569 else
19570   case $ac_pt_PKG_CONFIG in
19571   [\\/]* | ?:[\\/]*)
19572   ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
19573   ;;
19574   *)
19575   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19576 for as_dir in $PATH
19577 do
19578   IFS=$as_save_IFS
19579   test -z "$as_dir" && as_dir=.
19580     for ac_exec_ext in '' $ac_executable_extensions; do
19581   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19582     ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
19583     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19584     break 2
19585   fi
19586 done
19587   done
19588 IFS=$as_save_IFS
19589 
19590   ;;
19591 esac
19592 fi
19593 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
19594 if test -n "$ac_pt_PKG_CONFIG"; then
19595   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
19596 $as_echo "$ac_pt_PKG_CONFIG" >&6; }
19597 else
19598   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19599 $as_echo "no" >&6; }
19600 fi
19601 
19602   if test "x$ac_pt_PKG_CONFIG" = x; then
19603     PKG_CONFIG=""
19604   else
19605     case $cross_compiling:$ac_tool_warned in
19606 yes:)
19607 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
19608 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
19609 ac_tool_warned=yes ;;
19610 esac
19611     PKG_CONFIG=$ac_pt_PKG_CONFIG
19612   fi
19613 else
19614   PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
19615 fi
19616 
19617 fi
19618 if test -n "$PKG_CONFIG"; then
19619         _pkg_min_version=0.9.0
19620         { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
19621 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
19622         if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
19623                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19624 $as_echo "yes" >&6; }
19625         else
19626                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19627 $as_echo "no" >&6; }
19628                 PKG_CONFIG=""
19629         fi
19630 
19631 fi
19632 
19633 # After basic tools have been setup, we can check build os specific details.
19634 
19635   ###############################################################################
19636 
19637   # Note that this is the build platform OS version!
19638 
19639   OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`"
19640   OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`"
19641   OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`"
19642   OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`"
19643 
19644 
19645 
19646 
19647 
19648 # Setup builddeps, for automatic downloading of tools we need.
19649 # This is needed before we can call BDEPS_CHECK_MODULE, which is done in
19650 # boot-jdk setup, but we need to have basic tools setup first.
19651 
19652 
19653 # Check whether --with-builddeps-conf was given.
19654 if test "${with_builddeps_conf+set}" = set; then :
19655   withval=$with_builddeps_conf;
19656 fi
19657 
19658 
19659 
19660 # Check whether --with-builddeps-server was given.
19661 if test "${with_builddeps_server+set}" = set; then :
19662   withval=$with_builddeps_server;
19663 fi
19664 
19665 
19666 
19667 # Check whether --with-builddeps-dir was given.
19668 if test "${with_builddeps_dir+set}" = set; then :
19669   withval=$with_builddeps_dir;
19670 else
19671   with_builddeps_dir=/localhome/builddeps
19672 fi
19673 
19674 
19675 
19676 # Check whether --with-builddeps-group was given.
19677 if test "${with_builddeps_group+set}" = set; then :
19678   withval=$with_builddeps_group;
19679 fi
19680 
19681 
19682 
19683 
19684   if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
19685     if test "x$with_builddeps_conf" != x; then
19686       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for supplied builddeps configuration file" >&5
19687 $as_echo_n "checking for supplied builddeps configuration file... " >&6; }
19688       builddepsfile=$with_builddeps_conf
19689       if test -s $builddepsfile; then
19690         . $builddepsfile
19691         { $as_echo "$as_me:${as_lineno-$LINENO}: result: loaded!" >&5
19692 $as_echo "loaded!" >&6; }
19693       else
19694         as_fn_error $? "The given builddeps conf file $with_builddeps_conf could not be loaded!" "$LINENO" 5
19695       fi
19696     else
19697       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for builddeps.conf files in sources..." >&5
19698 $as_echo_n "checking for builddeps.conf files in sources...... " >&6; }
19699       builddepsfile=`mktemp`
19700       touch $builddepsfile
19701       # Put all found confs into a single file.
19702       find ${SRC_ROOT} -name builddeps.conf -exec cat \{\} \; >> $builddepsfile
19703       # Source the file to acquire the variables
19704       if test -s $builddepsfile; then
19705         . $builddepsfile
19706         { $as_echo "$as_me:${as_lineno-$LINENO}: result: found at least one!" >&5
19707 $as_echo "found at least one!" >&6; }
19708       else
19709         as_fn_error $? "Could not find any builddeps.conf at all!" "$LINENO" 5
19710       fi
19711     fi
19712     # Create build and target names that use _ instead of "-" and ".".
19713     # This is necessary to use them in variable names.
19714     build_var=`echo ${OPENJDK_BUILD_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19715     target_var=`echo ${OPENJDK_TARGET_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19716     # Extract rewrite information for build and target
19717     eval rewritten_build=\${REWRITE_${build_var}}
19718     if test "x$rewritten_build" = x; then
19719       rewritten_build=${OPENJDK_BUILD_AUTOCONF_NAME}
19720       echo Build stays the same $rewritten_build
19721     else
19722       echo Rewriting build for builddeps into $rewritten_build
19723     fi
19724     eval rewritten_target=\${REWRITE_${target_var}}
19725     if test "x$rewritten_target" = x; then
19726       rewritten_target=${OPENJDK_TARGET_AUTOCONF_NAME}
19727       echo Target stays the same $rewritten_target
19728     else
19729       echo Rewriting target for builddeps into $rewritten_target
19730     fi
19731     rewritten_build_var=`echo ${rewritten_build} | tr '-' '_' | tr '.' '_'`
19732     rewritten_target_var=`echo ${rewritten_target} | tr '-' '_' | tr '.' '_'`
19733   fi
19734   for ac_prog in 7z unzip
19735 do
19736   # Extract the first word of "$ac_prog", so it can be a program name with args.
19737 set dummy $ac_prog; ac_word=$2
19738 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19739 $as_echo_n "checking for $ac_word... " >&6; }
19740 if ${ac_cv_prog_BDEPS_UNZIP+:} false; then :
19741   $as_echo_n "(cached) " >&6
19742 else
19743   if test -n "$BDEPS_UNZIP"; then
19744   ac_cv_prog_BDEPS_UNZIP="$BDEPS_UNZIP" # Let the user override the test.
19745 else
19746 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19747 for as_dir in $PATH
19748 do
19749   IFS=$as_save_IFS
19750   test -z "$as_dir" && as_dir=.
19751     for ac_exec_ext in '' $ac_executable_extensions; do
19752   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19753     ac_cv_prog_BDEPS_UNZIP="$ac_prog"
19754     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19755     break 2
19756   fi
19757 done
19758   done
19759 IFS=$as_save_IFS
19760 
19761 fi
19762 fi
19763 BDEPS_UNZIP=$ac_cv_prog_BDEPS_UNZIP
19764 if test -n "$BDEPS_UNZIP"; then
19765   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_UNZIP" >&5
19766 $as_echo "$BDEPS_UNZIP" >&6; }
19767 else
19768   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19769 $as_echo "no" >&6; }
19770 fi
19771 
19772 
19773   test -n "$BDEPS_UNZIP" && break
19774 done
19775 
19776   if test "x$BDEPS_UNZIP" = x7z; then
19777     BDEPS_UNZIP="7z x"
19778   fi
19779 
19780   for ac_prog in wget lftp ftp
19781 do
19782   # Extract the first word of "$ac_prog", so it can be a program name with args.
19783 set dummy $ac_prog; ac_word=$2
19784 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19785 $as_echo_n "checking for $ac_word... " >&6; }
19786 if ${ac_cv_prog_BDEPS_FTP+:} false; then :
19787   $as_echo_n "(cached) " >&6
19788 else
19789   if test -n "$BDEPS_FTP"; then
19790   ac_cv_prog_BDEPS_FTP="$BDEPS_FTP" # Let the user override the test.
19791 else
19792 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19793 for as_dir in $PATH
19794 do
19795   IFS=$as_save_IFS
19796   test -z "$as_dir" && as_dir=.
19797     for ac_exec_ext in '' $ac_executable_extensions; do
19798   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19799     ac_cv_prog_BDEPS_FTP="$ac_prog"
19800     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19801     break 2
19802   fi
19803 done
19804   done
19805 IFS=$as_save_IFS
19806 
19807 fi
19808 fi
19809 BDEPS_FTP=$ac_cv_prog_BDEPS_FTP
19810 if test -n "$BDEPS_FTP"; then
19811   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_FTP" >&5
19812 $as_echo "$BDEPS_FTP" >&6; }
19813 else
19814   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19815 $as_echo "no" >&6; }
19816 fi
19817 
19818 
19819   test -n "$BDEPS_FTP" && break
19820 done
19821 
19822 
19823 
19824 ###############################################################################
19825 #
19826 # Determine OpenJDK variants, options and version numbers.
19827 #
19828 ###############################################################################
19829 
19830 # We need build & target for this.
19831 
19832 
19833   ###############################################################################
19834   #
19835   # Should we build a JDK/JVM with headful support (ie a graphical ui)?
19836   # We always build headless support.
19837   #
19838   { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
19839 $as_echo_n "checking headful support... " >&6; }
19840   # Check whether --enable-headful was given.
19841 if test "${enable_headful+set}" = set; then :
19842   enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
19843 else
19844   SUPPORT_HEADFUL=yes
19845 fi
19846 
19847 
19848   SUPPORT_HEADLESS=yes
19849   BUILD_HEADLESS="BUILD_HEADLESS:=true"
19850 
19851   if test "x$SUPPORT_HEADFUL" = xyes; then
19852     # We are building both headful and headless.
19853     headful_msg="include support for both headful and headless"
19854   fi
19855 
19856   if test "x$SUPPORT_HEADFUL" = xno; then
19857     # Thus we are building headless only.
19858     BUILD_HEADLESS="BUILD_HEADLESS:=true"
19859     headful_msg="headless only"
19860   fi
19861 
19862   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
19863 $as_echo "$headful_msg" >&6; }
19864 
19865 
19866 
19867 
19868 
19869   # Control wether Hotspot runs Queens test after build.
19870   # Check whether --enable-hotspot-test-in-build was given.
19871 if test "${enable_hotspot_test_in_build+set}" = set; then :
19872   enableval=$enable_hotspot_test_in_build;
19873 else
19874   enable_hotspot_test_in_build=no
19875 fi
19876 
19877   if test "x$enable_hotspot_test_in_build" = "xyes"; then
19878     TEST_IN_BUILD=true
19879   else
19880     TEST_IN_BUILD=false
19881   fi
19882 
19883 
19884   ###############################################################################
19885   #
19886   # Choose cacerts source file
19887   #
19888 
19889 # Check whether --with-cacerts-file was given.
19890 if test "${with_cacerts_file+set}" = set; then :
19891   withval=$with_cacerts_file;
19892 fi
19893 
19894   if test "x$with_cacerts_file" != x; then
19895     CACERTS_FILE=$with_cacerts_file
19896   fi
19897 
19898 
19899   ###############################################################################
19900   #
19901   # Enable or disable unlimited crypto
19902   #
19903   # Check whether --enable-unlimited-crypto was given.
19904 if test "${enable_unlimited_crypto+set}" = set; then :
19905   enableval=$enable_unlimited_crypto;
19906 else
19907   enable_unlimited_crypto=no
19908 fi
19909 
19910   if test "x$enable_unlimited_crypto" = "xyes"; then
19911     UNLIMITED_CRYPTO=true
19912   else
19913     UNLIMITED_CRYPTO=false
19914   fi
19915 
19916 
19917   ###############################################################################
19918   #
19919   # Enable or disable the elliptic curve crypto implementation
19920   #
19921 
19922 
19923   ###############################################################################
19924   #
19925   # --enable-rmiconnector-iiop
19926   #
19927   # Check whether --enable-rmiconnector-iiop was given.
19928 if test "${enable_rmiconnector_iiop+set}" = set; then :
19929   enableval=$enable_rmiconnector_iiop;
19930 fi
19931 
19932   if test "x$enable_rmiconnector_iiop" = "xyes"; then
19933     RMICONNECTOR_IIOP=true
19934   else
19935     RMICONNECTOR_IIOP=false
19936   fi
19937 
19938 
19939   ###############################################################################
19940   #
19941   # Compress jars
19942   #
19943   COMPRESS_JARS=false
19944 
19945 
19946 
19947 
19948   # Source the version numbers
19949   . $AUTOCONF_DIR/version-numbers
19950 
19951   # Get the settings from parameters
19952 
19953 # Check whether --with-milestone was given.
19954 if test "${with_milestone+set}" = set; then :
19955   withval=$with_milestone;
19956 fi
19957 
19958   if test "x$with_milestone" = xyes; then
19959     as_fn_error $? "Milestone must have a value" "$LINENO" 5
19960   elif test "x$with_milestone" != x; then
19961     MILESTONE="$with_milestone"
19962   fi
19963   if test "x$MILESTONE" = x; then
19964     MILESTONE=internal
19965   fi
19966 
19967 
19968 # Check whether --with-update-version was given.
19969 if test "${with_update_version+set}" = set; then :
19970   withval=$with_update_version;
19971 fi
19972 
19973   if test "x$with_update_version" = xyes; then
19974     as_fn_error $? "Update version must have a value" "$LINENO" 5
19975   elif test "x$with_update_version" != x; then
19976     JDK_UPDATE_VERSION="$with_update_version"
19977     # On macosx 10.7, it's not possible to set --with-update-version=0X due
19978     # to a bug in expr (which reduces it to just X). To work around this, we
19979     # always add a 0 to one digit update versions.
19980     if test "${#JDK_UPDATE_VERSION}" = "1"; then
19981       JDK_UPDATE_VERSION="0${JDK_UPDATE_VERSION}"
19982     fi
19983   fi
19984 
19985 
19986 # Check whether --with-user-release-suffix was given.
19987 if test "${with_user_release_suffix+set}" = set; then :
19988   withval=$with_user_release_suffix;
19989 fi
19990 
19991   if test "x$with_user_release_suffix" = xyes; then
19992     as_fn_error $? "Release suffix must have a value" "$LINENO" 5
19993   elif test "x$with_user_release_suffix" != x; then
19994     USER_RELEASE_SUFFIX="$with_user_release_suffix"
19995   fi
19996 
19997 
19998 # Check whether --with-build-number was given.
19999 if test "${with_build_number+set}" = set; then :
20000   withval=$with_build_number;
20001 fi
20002 
20003   if test "x$with_build_number" = xyes; then
20004     as_fn_error $? "Build number must have a value" "$LINENO" 5
20005   elif test "x$with_build_number" != x; then
20006     JDK_BUILD_NUMBER="$with_build_number"
20007   fi
20008   # Define default USER_RELEASE_SUFFIX if BUILD_NUMBER and USER_RELEASE_SUFFIX are not set
20009   if test "x$JDK_BUILD_NUMBER" = x; then
20010     JDK_BUILD_NUMBER=b00
20011     if test "x$USER_RELEASE_SUFFIX" = x; then
20012       BUILD_DATE=`date '+%Y_%m_%d_%H_%M'`
20013       # Avoid [:alnum:] since it depends on the locale.
20014       CLEAN_USERNAME=`echo "$USER" | $TR -d -c 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'`
20015       USER_RELEASE_SUFFIX=`echo "${CLEAN_USERNAME}_${BUILD_DATE}" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20016     fi
20017   fi
20018 
20019   # Now set the JDK version, milestone, build number etc.
20020 
20021 
20022 
20023 
20024 
20025 
20026 
20027 
20028 
20029 
20030 
20031 
20032 
20033 
20034 
20035 
20036 # Check whether --with-copyright-year was given.
20037 if test "${with_copyright_year+set}" = set; then :
20038   withval=$with_copyright_year;
20039 fi
20040 
20041   if test "x$with_copyright_year" = xyes; then
20042     as_fn_error $? "Copyright year must have a value" "$LINENO" 5
20043   elif test "x$with_copyright_year" != x; then
20044     COPYRIGHT_YEAR="$with_copyright_year"
20045   else
20046     COPYRIGHT_YEAR=`date +'%Y'`
20047   fi
20048 
20049 
20050   if test "x$JDK_UPDATE_VERSION" != x; then
20051     JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}_${JDK_UPDATE_VERSION}"
20052   else
20053     JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}"
20054   fi
20055 
20056 
20057   COOKED_BUILD_NUMBER=`$ECHO $JDK_BUILD_NUMBER | $SED -e 's/^b//' -e 's/^0//'`
20058 
20059 
20060 
20061 ###############################################################################
20062 #
20063 # Setup BootJDK, used to bootstrap the build.
20064 #
20065 ###############################################################################
20066 
20067 
20068   BOOT_JDK_FOUND=no
20069 
20070 # Check whether --with-boot-jdk was given.
20071 if test "${with_boot_jdk+set}" = set; then :
20072   withval=$with_boot_jdk;
20073 fi
20074 
20075 
20076   # We look for the Boot JDK through various means, going from more certain to
20077   # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
20078   # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
20079   # must check if this is indeed valid; otherwise we'll continue looking.
20080 
20081   # Test: Is bootjdk explicitely set by command line arguments?
20082 
20083   if test "x$BOOT_JDK_FOUND" = xno; then
20084     # Now execute the test
20085 
20086   if test "x$with_boot_jdk" != x; then
20087     BOOT_JDK=$with_boot_jdk
20088     BOOT_JDK_FOUND=maybe
20089     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
20090 $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
20091   fi
20092 
20093 
20094     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20095     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20096       # Do we have a bin/java?
20097       if test ! -x "$BOOT_JDK/bin/java"; then
20098         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20099 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20100         BOOT_JDK_FOUND=no
20101       else
20102         # Do we have a bin/javac?
20103         if test ! -x "$BOOT_JDK/bin/javac"; then
20104           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20105 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20106           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20107 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20108           BOOT_JDK_FOUND=no
20109         else
20110           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20111           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20112 
20113           # Extra M4 quote needed to protect [] in grep expression.
20114           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
20115           if test "x$FOUND_CORRECT_VERSION" = x; then
20116             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20117 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20118             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20119 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20120             BOOT_JDK_FOUND=no
20121           else
20122             # We're done! :-)
20123             BOOT_JDK_FOUND=yes
20124 
20125   # Only process if variable expands to non-empty
20126 
20127   if test "x$BOOT_JDK" != x; then
20128     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20129 
20130   # Input might be given as Windows format, start by converting to
20131   # unix format.
20132   path="$BOOT_JDK"
20133   new_path=`$CYGPATH -u "$path"`
20134 
20135   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20136   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20137   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20138   # "foo.exe" is OK but "foo" is an error.
20139   #
20140   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20141   # It is also a way to make sure we got the proper file name for the real test later on.
20142   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20143   if test "x$test_shortpath" = x; then
20144     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20145 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20146     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20147   fi
20148 
20149   # Call helper function which possibly converts this using DOS-style short mode.
20150   # If so, the updated path is stored in $new_path.
20151 
20152   input_path="$new_path"
20153   # Check if we need to convert this using DOS-style short mode. If the path
20154   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20155   # take no chances and rewrite it.
20156   # Note: m4 eats our [], so we need to use [ and ] instead.
20157   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20158   if test "x$has_forbidden_chars" != x; then
20159     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20160     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20161     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20162     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20163       # Going to short mode and back again did indeed matter. Since short mode is
20164       # case insensitive, let's make it lowercase to improve readability.
20165       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20166       # Now convert it back to Unix-stile (cygpath)
20167       input_path=`$CYGPATH -u "$shortmode_path"`
20168       new_path="$input_path"
20169     fi
20170   fi
20171 
20172   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20173   if test "x$test_cygdrive_prefix" = x; then
20174     # As a simple fix, exclude /usr/bin since it's not a real path.
20175     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20176       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20177       # a path prefixed by /cygdrive for fixpath to work.
20178       new_path="$CYGWIN_ROOT_PATH$input_path"
20179     fi
20180   fi
20181 
20182 
20183   if test "x$path" != "x$new_path"; then
20184     BOOT_JDK="$new_path"
20185     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20186 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20187   fi
20188 
20189     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20190 
20191   path="$BOOT_JDK"
20192   has_colon=`$ECHO $path | $GREP ^.:`
20193   new_path="$path"
20194   if test "x$has_colon" = x; then
20195     # Not in mixed or Windows style, start by that.
20196     new_path=`cmd //c echo $path`
20197   fi
20198 
20199 
20200   input_path="$new_path"
20201   # Check if we need to convert this using DOS-style short mode. If the path
20202   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20203   # take no chances and rewrite it.
20204   # Note: m4 eats our [], so we need to use [ and ] instead.
20205   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20206   if test "x$has_forbidden_chars" != x; then
20207     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20208     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20209   fi
20210 
20211 
20212   windows_path="$new_path"
20213   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20214     unix_path=`$CYGPATH -u "$windows_path"`
20215     new_path="$unix_path"
20216   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20217     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20218     new_path="$unix_path"
20219   fi
20220 
20221   if test "x$path" != "x$new_path"; then
20222     BOOT_JDK="$new_path"
20223     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20224 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20225   fi
20226 
20227   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20228   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20229 
20230     else
20231       # We're on a unix platform. Hooray! :)
20232       path="$BOOT_JDK"
20233       has_space=`$ECHO "$path" | $GREP " "`
20234       if test "x$has_space" != x; then
20235         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20236 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20237         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20238       fi
20239 
20240       # Use eval to expand a potential ~
20241       eval path="$path"
20242       if test ! -f "$path" && test ! -d "$path"; then
20243         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20244       fi
20245 
20246       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20247     fi
20248   fi
20249 
20250             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20251 $as_echo_n "checking for Boot JDK... " >&6; }
20252             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20253 $as_echo "$BOOT_JDK" >&6; }
20254             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20255 $as_echo_n "checking Boot JDK version... " >&6; }
20256             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20257             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20258 $as_echo "$BOOT_JDK_VERSION" >&6; }
20259           fi # end check jdk version
20260         fi # end check javac
20261       fi # end check java
20262     fi # end check boot jdk found
20263   fi
20264 
20265   if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
20266     # Having specified an argument which is incorrect will produce an instant failure;
20267     # we should not go on looking
20268     as_fn_error $? "The path given by --with-boot-jdk does not contain a valid Boot JDK" "$LINENO" 5
20269   fi
20270 
20271   # Test: Is bootjdk available from builddeps?
20272 
20273   if test "x$BOOT_JDK_FOUND" = xno; then
20274     # Now execute the test
20275 
20276 
20277 
20278   if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
20279     # Source the builddeps file again, to make sure it uses the latest variables!
20280     . $builddepsfile
20281     # Look for a target and build machine specific resource!
20282     eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}_TARGET_${rewritten_target_var}}
20283     if test "x$resource" = x; then
20284       # Ok, lets instead look for a target specific resource
20285       eval resource=\${builddep_bootjdk_TARGET_${rewritten_target_var}}
20286     fi
20287     if test "x$resource" = x; then
20288       # Ok, lets instead look for a build specific resource
20289       eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}}
20290     fi
20291     if test "x$resource" = x; then
20292       # Ok, lets instead look for a generic resource
20293       # (The bootjdk comes from M4 and not the shell, thus no need for eval here.)
20294       resource=${builddep_bootjdk}
20295     fi
20296     if test "x$resource" != x; then
20297       { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for bootjdk" >&5
20298 $as_echo "$as_me: Using builddeps $resource for bootjdk" >&6;}
20299       # If the resource in the builddeps.conf file is an existing directory,
20300       # for example /java/linux/cups
20301       if test -d ${resource}; then
20302         depdir=${resource}
20303       else
20304 
20305   # bootjdk is for example mymodule
20306   # $resource is for example libs/general/libmymod_1_2_3.zip
20307   # $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps
20308   # $with_builddeps_dir is for example /localhome/builddeps
20309   # depdir is the name of the variable into which we store the depdir, eg MYMOD
20310   # Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and
20311   # unzip into the directory: /localhome/builddeps/libmymod_1_2_3
20312   filename=`basename $resource`
20313   filebase=`echo $filename | sed 's/\.[^\.]*$//'`
20314   filebase=${filename%%.*}
20315   extension=${filename#*.}
20316   installdir=$with_builddeps_dir/$filebase
20317   if test ! -f $installdir/$filename.unpacked; then
20318     { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&5
20319 $as_echo "$as_me: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&6;}
20320     if test ! -d $installdir; then
20321       mkdir -p $installdir
20322     fi
20323     if test ! -d $installdir; then
20324       as_fn_error $? "Could not create directory $installdir" "$LINENO" 5
20325     fi
20326     tmpfile=`mktemp $installdir/bootjdk.XXXXXXXXX`
20327     touch $tmpfile
20328     if test ! -f $tmpfile; then
20329       as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5
20330     fi
20331 
20332   # $with_builddeps_server/$resource  is the ftp://abuilddeps.server.com/libs/cups.zip
20333   # $tmpfile is the local file name for the downloaded file.
20334   VALID_TOOL=no
20335   if test "x$BDEPS_FTP" = xwget; then
20336     VALID_TOOL=yes
20337     wget -O $tmpfile $with_builddeps_server/$resource
20338   fi
20339   if test "x$BDEPS_FTP" = xlftp; then
20340     VALID_TOOL=yes
20341     lftp -c "get $with_builddeps_server/$resource  -o $tmpfile"
20342   fi
20343   if test "x$BDEPS_FTP" = xftp; then
20344     VALID_TOOL=yes
20345     FTPSERVER=`echo $with_builddeps_server/$resource  | cut -f 3 -d '/'`
20346     FTPPATH=`echo $with_builddeps_server/$resource  | cut -f 4- -d '/'`
20347     FTPUSERPWD=${FTPSERVER%%@*}
20348     if test "x$FTPSERVER" != "x$FTPUSERPWD"; then
20349       FTPUSER=${userpwd%%:*}
20350       FTPPWD=${userpwd#*@}
20351       FTPSERVER=${FTPSERVER#*@}
20352     else
20353       FTPUSER=ftp
20354       FTPPWD=ftp
20355     fi
20356     # the "pass" command does not work on some
20357     # ftp clients (read ftp.exe) but if it works,
20358     # passive mode is better!
20359     ( \
20360         echo "user $FTPUSER $FTPPWD"        ; \
20361         echo "pass"                         ; \
20362         echo "bin"                          ; \
20363         echo "get $FTPPATH $tmpfile"              ; \
20364     ) | ftp -in $FTPSERVER
20365   fi
20366   if test "x$VALID_TOOL" != xyes; then
20367     as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5
20368   fi
20369 
20370     mv $tmpfile $installdir/$filename
20371     if test ! -s $installdir/$filename; then
20372       as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5
20373     fi
20374     case "$extension" in
20375       zip)  echo "Unzipping $installdir/$filename..."
20376         (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked)
20377         ;;
20378       tar.gz) echo "Untaring $installdir/$filename..."
20379         (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
20380         ;;
20381       tgz) echo "Untaring $installdir/$filename..."
20382         (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
20383         ;;
20384       *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5
20385         ;;
20386     esac
20387   fi
20388   if test -f $installdir/$filename.unpacked; then
20389     depdir=$installdir
20390   fi
20391 
20392       fi
20393       # Source the builddeps file again, because in the previous command, the depdir
20394       # was updated to point at the current build dependency install directory.
20395       . $builddepsfile
20396       # Now extract variables from the builddeps.conf files.
20397       theroot=${builddep_bootjdk_ROOT}
20398       thecflags=${builddep_bootjdk_CFLAGS}
20399       thelibs=${builddep_bootjdk_LIBS}
20400       if test "x$depdir" = x; then
20401         as_fn_error $? "Could not download build dependency bootjdk" "$LINENO" 5
20402       fi
20403       BOOT_JDK=$depdir
20404       if test "x$theroot" != x; then
20405         BOOT_JDK="$theroot"
20406       fi
20407       if test "x$thecflags" != x; then
20408         BOOT_JDK_CFLAGS="$thecflags"
20409       fi
20410       if test "x$thelibs" != x; then
20411         BOOT_JDK_LIBS="$thelibs"
20412       fi
20413       BOOT_JDK_FOUND=maybe
20414       else BOOT_JDK_FOUND=no
20415 
20416     fi
20417     else BOOT_JDK_FOUND=no
20418 
20419   fi
20420 
20421 
20422 
20423     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20424     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20425       # Do we have a bin/java?
20426       if test ! -x "$BOOT_JDK/bin/java"; then
20427         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20428 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20429         BOOT_JDK_FOUND=no
20430       else
20431         # Do we have a bin/javac?
20432         if test ! -x "$BOOT_JDK/bin/javac"; then
20433           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20434 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20435           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20436 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20437           BOOT_JDK_FOUND=no
20438         else
20439           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20440           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20441 
20442           # Extra M4 quote needed to protect [] in grep expression.
20443           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
20444           if test "x$FOUND_CORRECT_VERSION" = x; then
20445             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20446 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20447             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20448 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20449             BOOT_JDK_FOUND=no
20450           else
20451             # We're done! :-)
20452             BOOT_JDK_FOUND=yes
20453 
20454   # Only process if variable expands to non-empty
20455 
20456   if test "x$BOOT_JDK" != x; then
20457     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20458 
20459   # Input might be given as Windows format, start by converting to
20460   # unix format.
20461   path="$BOOT_JDK"
20462   new_path=`$CYGPATH -u "$path"`
20463 
20464   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20465   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20466   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20467   # "foo.exe" is OK but "foo" is an error.
20468   #
20469   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20470   # It is also a way to make sure we got the proper file name for the real test later on.
20471   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20472   if test "x$test_shortpath" = x; then
20473     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20474 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20475     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20476   fi
20477 
20478   # Call helper function which possibly converts this using DOS-style short mode.
20479   # If so, the updated path is stored in $new_path.
20480 
20481   input_path="$new_path"
20482   # Check if we need to convert this using DOS-style short mode. If the path
20483   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20484   # take no chances and rewrite it.
20485   # Note: m4 eats our [], so we need to use [ and ] instead.
20486   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20487   if test "x$has_forbidden_chars" != x; then
20488     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20489     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20490     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20491     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20492       # Going to short mode and back again did indeed matter. Since short mode is
20493       # case insensitive, let's make it lowercase to improve readability.
20494       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20495       # Now convert it back to Unix-stile (cygpath)
20496       input_path=`$CYGPATH -u "$shortmode_path"`
20497       new_path="$input_path"
20498     fi
20499   fi
20500 
20501   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20502   if test "x$test_cygdrive_prefix" = x; then
20503     # As a simple fix, exclude /usr/bin since it's not a real path.
20504     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20505       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20506       # a path prefixed by /cygdrive for fixpath to work.
20507       new_path="$CYGWIN_ROOT_PATH$input_path"
20508     fi
20509   fi
20510 
20511 
20512   if test "x$path" != "x$new_path"; then
20513     BOOT_JDK="$new_path"
20514     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20515 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20516   fi
20517 
20518     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20519 
20520   path="$BOOT_JDK"
20521   has_colon=`$ECHO $path | $GREP ^.:`
20522   new_path="$path"
20523   if test "x$has_colon" = x; then
20524     # Not in mixed or Windows style, start by that.
20525     new_path=`cmd //c echo $path`
20526   fi
20527 
20528 
20529   input_path="$new_path"
20530   # Check if we need to convert this using DOS-style short mode. If the path
20531   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20532   # take no chances and rewrite it.
20533   # Note: m4 eats our [], so we need to use [ and ] instead.
20534   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20535   if test "x$has_forbidden_chars" != x; then
20536     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20537     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20538   fi
20539 
20540 
20541   windows_path="$new_path"
20542   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20543     unix_path=`$CYGPATH -u "$windows_path"`
20544     new_path="$unix_path"
20545   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20546     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20547     new_path="$unix_path"
20548   fi
20549 
20550   if test "x$path" != "x$new_path"; then
20551     BOOT_JDK="$new_path"
20552     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20553 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20554   fi
20555 
20556   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20557   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20558 
20559     else
20560       # We're on a unix platform. Hooray! :)
20561       path="$BOOT_JDK"
20562       has_space=`$ECHO "$path" | $GREP " "`
20563       if test "x$has_space" != x; then
20564         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20565 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20566         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20567       fi
20568 
20569       # Use eval to expand a potential ~
20570       eval path="$path"
20571       if test ! -f "$path" && test ! -d "$path"; then
20572         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20573       fi
20574 
20575       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20576     fi
20577   fi
20578 
20579             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20580 $as_echo_n "checking for Boot JDK... " >&6; }
20581             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20582 $as_echo "$BOOT_JDK" >&6; }
20583             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20584 $as_echo_n "checking Boot JDK version... " >&6; }
20585             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20586             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20587 $as_echo "$BOOT_JDK_VERSION" >&6; }
20588           fi # end check jdk version
20589         fi # end check javac
20590       fi # end check java
20591     fi # end check boot jdk found
20592   fi
20593 
20594 
20595   # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
20596 
20597   if test "x$BOOT_JDK_FOUND" = xno; then
20598     # Now execute the test
20599 
20600   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
20601     # First check at user selected default
20602 
20603   if test "x$BOOT_JDK_FOUND" = xno; then
20604     # Now execute the test
20605 
20606   if test -x /usr/libexec/java_home; then
20607     BOOT_JDK=`/usr/libexec/java_home `
20608     BOOT_JDK_FOUND=maybe
20609     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home " >&5
20610 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home " >&6;}
20611   fi
20612 
20613 
20614     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20615     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20616       # Do we have a bin/java?
20617       if test ! -x "$BOOT_JDK/bin/java"; then
20618         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20619 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20620         BOOT_JDK_FOUND=no
20621       else
20622         # Do we have a bin/javac?
20623         if test ! -x "$BOOT_JDK/bin/javac"; then
20624           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20625 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20626           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20627 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20628           BOOT_JDK_FOUND=no
20629         else
20630           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20631           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20632 
20633           # Extra M4 quote needed to protect [] in grep expression.
20634           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
20635           if test "x$FOUND_CORRECT_VERSION" = x; then
20636             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20637 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20638             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20639 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20640             BOOT_JDK_FOUND=no
20641           else
20642             # We're done! :-)
20643             BOOT_JDK_FOUND=yes
20644 
20645   # Only process if variable expands to non-empty
20646 
20647   if test "x$BOOT_JDK" != x; then
20648     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20649 
20650   # Input might be given as Windows format, start by converting to
20651   # unix format.
20652   path="$BOOT_JDK"
20653   new_path=`$CYGPATH -u "$path"`
20654 
20655   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20656   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20657   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20658   # "foo.exe" is OK but "foo" is an error.
20659   #
20660   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20661   # It is also a way to make sure we got the proper file name for the real test later on.
20662   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20663   if test "x$test_shortpath" = x; then
20664     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20665 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20666     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20667   fi
20668 
20669   # Call helper function which possibly converts this using DOS-style short mode.
20670   # If so, the updated path is stored in $new_path.
20671 
20672   input_path="$new_path"
20673   # Check if we need to convert this using DOS-style short mode. If the path
20674   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20675   # take no chances and rewrite it.
20676   # Note: m4 eats our [], so we need to use [ and ] instead.
20677   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20678   if test "x$has_forbidden_chars" != x; then
20679     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20680     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20681     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20682     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20683       # Going to short mode and back again did indeed matter. Since short mode is
20684       # case insensitive, let's make it lowercase to improve readability.
20685       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20686       # Now convert it back to Unix-stile (cygpath)
20687       input_path=`$CYGPATH -u "$shortmode_path"`
20688       new_path="$input_path"
20689     fi
20690   fi
20691 
20692   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20693   if test "x$test_cygdrive_prefix" = x; then
20694     # As a simple fix, exclude /usr/bin since it's not a real path.
20695     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20696       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20697       # a path prefixed by /cygdrive for fixpath to work.
20698       new_path="$CYGWIN_ROOT_PATH$input_path"
20699     fi
20700   fi
20701 
20702 
20703   if test "x$path" != "x$new_path"; then
20704     BOOT_JDK="$new_path"
20705     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20706 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20707   fi
20708 
20709     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20710 
20711   path="$BOOT_JDK"
20712   has_colon=`$ECHO $path | $GREP ^.:`
20713   new_path="$path"
20714   if test "x$has_colon" = x; then
20715     # Not in mixed or Windows style, start by that.
20716     new_path=`cmd //c echo $path`
20717   fi
20718 
20719 
20720   input_path="$new_path"
20721   # Check if we need to convert this using DOS-style short mode. If the path
20722   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20723   # take no chances and rewrite it.
20724   # Note: m4 eats our [], so we need to use [ and ] instead.
20725   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20726   if test "x$has_forbidden_chars" != x; then
20727     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20728     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20729   fi
20730 
20731 
20732   windows_path="$new_path"
20733   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20734     unix_path=`$CYGPATH -u "$windows_path"`
20735     new_path="$unix_path"
20736   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20737     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20738     new_path="$unix_path"
20739   fi
20740 
20741   if test "x$path" != "x$new_path"; then
20742     BOOT_JDK="$new_path"
20743     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20744 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20745   fi
20746 
20747   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20748   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20749 
20750     else
20751       # We're on a unix platform. Hooray! :)
20752       path="$BOOT_JDK"
20753       has_space=`$ECHO "$path" | $GREP " "`
20754       if test "x$has_space" != x; then
20755         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20756 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20757         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20758       fi
20759 
20760       # Use eval to expand a potential ~
20761       eval path="$path"
20762       if test ! -f "$path" && test ! -d "$path"; then
20763         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20764       fi
20765 
20766       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20767     fi
20768   fi
20769 
20770             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20771 $as_echo_n "checking for Boot JDK... " >&6; }
20772             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20773 $as_echo "$BOOT_JDK" >&6; }
20774             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20775 $as_echo_n "checking Boot JDK version... " >&6; }
20776             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20777             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20778 $as_echo "$BOOT_JDK_VERSION" >&6; }
20779           fi # end check jdk version
20780         fi # end check javac
20781       fi # end check java
20782     fi # end check boot jdk found
20783   fi
20784 
20785     # If that did not work out (e.g. too old), try explicit versions instead
20786 
20787   if test "x$BOOT_JDK_FOUND" = xno; then
20788     # Now execute the test
20789 
20790   if test -x /usr/libexec/java_home; then
20791     BOOT_JDK=`/usr/libexec/java_home -v 1.9`
20792     BOOT_JDK_FOUND=maybe
20793     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&5
20794 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&6;}
20795   fi
20796 
20797 
20798     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20799     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20800       # Do we have a bin/java?
20801       if test ! -x "$BOOT_JDK/bin/java"; then
20802         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20803 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20804         BOOT_JDK_FOUND=no
20805       else
20806         # Do we have a bin/javac?
20807         if test ! -x "$BOOT_JDK/bin/javac"; then
20808           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20809 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20810           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20811 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20812           BOOT_JDK_FOUND=no
20813         else
20814           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20815           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20816 
20817           # Extra M4 quote needed to protect [] in grep expression.
20818           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
20819           if test "x$FOUND_CORRECT_VERSION" = x; then
20820             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20821 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20822             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20823 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20824             BOOT_JDK_FOUND=no
20825           else
20826             # We're done! :-)
20827             BOOT_JDK_FOUND=yes
20828 
20829   # Only process if variable expands to non-empty
20830 
20831   if test "x$BOOT_JDK" != x; then
20832     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20833 
20834   # Input might be given as Windows format, start by converting to
20835   # unix format.
20836   path="$BOOT_JDK"
20837   new_path=`$CYGPATH -u "$path"`
20838 
20839   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20840   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20841   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20842   # "foo.exe" is OK but "foo" is an error.
20843   #
20844   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20845   # It is also a way to make sure we got the proper file name for the real test later on.
20846   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20847   if test "x$test_shortpath" = x; then
20848     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20849 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20850     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20851   fi
20852 
20853   # Call helper function which possibly converts this using DOS-style short mode.
20854   # If so, the updated path is stored in $new_path.
20855 
20856   input_path="$new_path"
20857   # Check if we need to convert this using DOS-style short mode. If the path
20858   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20859   # take no chances and rewrite it.
20860   # Note: m4 eats our [], so we need to use [ and ] instead.
20861   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20862   if test "x$has_forbidden_chars" != x; then
20863     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20864     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20865     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20866     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20867       # Going to short mode and back again did indeed matter. Since short mode is
20868       # case insensitive, let's make it lowercase to improve readability.
20869       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20870       # Now convert it back to Unix-stile (cygpath)
20871       input_path=`$CYGPATH -u "$shortmode_path"`
20872       new_path="$input_path"
20873     fi
20874   fi
20875 
20876   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20877   if test "x$test_cygdrive_prefix" = x; then
20878     # As a simple fix, exclude /usr/bin since it's not a real path.
20879     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20880       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20881       # a path prefixed by /cygdrive for fixpath to work.
20882       new_path="$CYGWIN_ROOT_PATH$input_path"
20883     fi
20884   fi
20885 
20886 
20887   if test "x$path" != "x$new_path"; then
20888     BOOT_JDK="$new_path"
20889     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20890 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20891   fi
20892 
20893     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20894 
20895   path="$BOOT_JDK"
20896   has_colon=`$ECHO $path | $GREP ^.:`
20897   new_path="$path"
20898   if test "x$has_colon" = x; then
20899     # Not in mixed or Windows style, start by that.
20900     new_path=`cmd //c echo $path`
20901   fi
20902 
20903 
20904   input_path="$new_path"
20905   # Check if we need to convert this using DOS-style short mode. If the path
20906   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20907   # take no chances and rewrite it.
20908   # Note: m4 eats our [], so we need to use [ and ] instead.
20909   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20910   if test "x$has_forbidden_chars" != x; then
20911     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20912     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20913   fi
20914 
20915 
20916   windows_path="$new_path"
20917   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20918     unix_path=`$CYGPATH -u "$windows_path"`
20919     new_path="$unix_path"
20920   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20921     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20922     new_path="$unix_path"
20923   fi
20924 
20925   if test "x$path" != "x$new_path"; then
20926     BOOT_JDK="$new_path"
20927     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20928 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20929   fi
20930 
20931   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20932   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20933 
20934     else
20935       # We're on a unix platform. Hooray! :)
20936       path="$BOOT_JDK"
20937       has_space=`$ECHO "$path" | $GREP " "`
20938       if test "x$has_space" != x; then
20939         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20940 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20941         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20942       fi
20943 
20944       # Use eval to expand a potential ~
20945       eval path="$path"
20946       if test ! -f "$path" && test ! -d "$path"; then
20947         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20948       fi
20949 
20950       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20951     fi
20952   fi
20953 
20954             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20955 $as_echo_n "checking for Boot JDK... " >&6; }
20956             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20957 $as_echo "$BOOT_JDK" >&6; }
20958             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20959 $as_echo_n "checking Boot JDK version... " >&6; }
20960             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20961             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20962 $as_echo "$BOOT_JDK_VERSION" >&6; }
20963           fi # end check jdk version
20964         fi # end check javac
20965       fi # end check java
20966     fi # end check boot jdk found
20967   fi
20968 
20969 
20970   if test "x$BOOT_JDK_FOUND" = xno; then
20971     # Now execute the test
20972 
20973   if test -x /usr/libexec/java_home; then
20974     BOOT_JDK=`/usr/libexec/java_home -v 1.8`
20975     BOOT_JDK_FOUND=maybe
20976     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&5
20977 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&6;}
20978   fi
20979 
20980 
20981     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20982     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20983       # Do we have a bin/java?
20984       if test ! -x "$BOOT_JDK/bin/java"; then
20985         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20986 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20987         BOOT_JDK_FOUND=no
20988       else
20989         # Do we have a bin/javac?
20990         if test ! -x "$BOOT_JDK/bin/javac"; then
20991           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20992 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20993           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20994 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20995           BOOT_JDK_FOUND=no
20996         else
20997           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20998           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20999 
21000           # Extra M4 quote needed to protect [] in grep expression.
21001           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
21002           if test "x$FOUND_CORRECT_VERSION" = x; then
21003             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21004 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21005             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21006 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21007             BOOT_JDK_FOUND=no
21008           else
21009             # We're done! :-)
21010             BOOT_JDK_FOUND=yes
21011 
21012   # Only process if variable expands to non-empty
21013 
21014   if test "x$BOOT_JDK" != x; then
21015     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21016 
21017   # Input might be given as Windows format, start by converting to
21018   # unix format.
21019   path="$BOOT_JDK"
21020   new_path=`$CYGPATH -u "$path"`
21021 
21022   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21023   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21024   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21025   # "foo.exe" is OK but "foo" is an error.
21026   #
21027   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21028   # It is also a way to make sure we got the proper file name for the real test later on.
21029   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21030   if test "x$test_shortpath" = x; then
21031     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21032 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21033     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21034   fi
21035 
21036   # Call helper function which possibly converts this using DOS-style short mode.
21037   # If so, the updated path is stored in $new_path.
21038 
21039   input_path="$new_path"
21040   # Check if we need to convert this using DOS-style short mode. If the path
21041   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21042   # take no chances and rewrite it.
21043   # Note: m4 eats our [], so we need to use [ and ] instead.
21044   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21045   if test "x$has_forbidden_chars" != x; then
21046     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21047     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21048     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21049     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21050       # Going to short mode and back again did indeed matter. Since short mode is
21051       # case insensitive, let's make it lowercase to improve readability.
21052       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21053       # Now convert it back to Unix-stile (cygpath)
21054       input_path=`$CYGPATH -u "$shortmode_path"`
21055       new_path="$input_path"
21056     fi
21057   fi
21058 
21059   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21060   if test "x$test_cygdrive_prefix" = x; then
21061     # As a simple fix, exclude /usr/bin since it's not a real path.
21062     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21063       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21064       # a path prefixed by /cygdrive for fixpath to work.
21065       new_path="$CYGWIN_ROOT_PATH$input_path"
21066     fi
21067   fi
21068 
21069 
21070   if test "x$path" != "x$new_path"; then
21071     BOOT_JDK="$new_path"
21072     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21073 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21074   fi
21075 
21076     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21077 
21078   path="$BOOT_JDK"
21079   has_colon=`$ECHO $path | $GREP ^.:`
21080   new_path="$path"
21081   if test "x$has_colon" = x; then
21082     # Not in mixed or Windows style, start by that.
21083     new_path=`cmd //c echo $path`
21084   fi
21085 
21086 
21087   input_path="$new_path"
21088   # Check if we need to convert this using DOS-style short mode. If the path
21089   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21090   # take no chances and rewrite it.
21091   # Note: m4 eats our [], so we need to use [ and ] instead.
21092   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21093   if test "x$has_forbidden_chars" != x; then
21094     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21095     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21096   fi
21097 
21098 
21099   windows_path="$new_path"
21100   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21101     unix_path=`$CYGPATH -u "$windows_path"`
21102     new_path="$unix_path"
21103   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21104     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21105     new_path="$unix_path"
21106   fi
21107 
21108   if test "x$path" != "x$new_path"; then
21109     BOOT_JDK="$new_path"
21110     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21111 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21112   fi
21113 
21114   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21115   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21116 
21117     else
21118       # We're on a unix platform. Hooray! :)
21119       path="$BOOT_JDK"
21120       has_space=`$ECHO "$path" | $GREP " "`
21121       if test "x$has_space" != x; then
21122         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21123 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21124         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21125       fi
21126 
21127       # Use eval to expand a potential ~
21128       eval path="$path"
21129       if test ! -f "$path" && test ! -d "$path"; then
21130         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21131       fi
21132 
21133       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21134     fi
21135   fi
21136 
21137             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21138 $as_echo_n "checking for Boot JDK... " >&6; }
21139             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21140 $as_echo "$BOOT_JDK" >&6; }
21141             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21142 $as_echo_n "checking Boot JDK version... " >&6; }
21143             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21144             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21145 $as_echo "$BOOT_JDK_VERSION" >&6; }
21146           fi # end check jdk version
21147         fi # end check javac
21148       fi # end check java
21149     fi # end check boot jdk found
21150   fi
21151 
21152 
21153   if test "x$BOOT_JDK_FOUND" = xno; then
21154     # Now execute the test
21155 
21156   if test -x /usr/libexec/java_home; then
21157     BOOT_JDK=`/usr/libexec/java_home -v 1.7`
21158     BOOT_JDK_FOUND=maybe
21159     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&5
21160 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&6;}
21161   fi
21162 
21163 
21164     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21165     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21166       # Do we have a bin/java?
21167       if test ! -x "$BOOT_JDK/bin/java"; then
21168         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21169 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21170         BOOT_JDK_FOUND=no
21171       else
21172         # Do we have a bin/javac?
21173         if test ! -x "$BOOT_JDK/bin/javac"; then
21174           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21175 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21176           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21177 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21178           BOOT_JDK_FOUND=no
21179         else
21180           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21181           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21182 
21183           # Extra M4 quote needed to protect [] in grep expression.
21184           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
21185           if test "x$FOUND_CORRECT_VERSION" = x; then
21186             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21187 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21188             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21189 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21190             BOOT_JDK_FOUND=no
21191           else
21192             # We're done! :-)
21193             BOOT_JDK_FOUND=yes
21194 
21195   # Only process if variable expands to non-empty
21196 
21197   if test "x$BOOT_JDK" != x; then
21198     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21199 
21200   # Input might be given as Windows format, start by converting to
21201   # unix format.
21202   path="$BOOT_JDK"
21203   new_path=`$CYGPATH -u "$path"`
21204 
21205   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21206   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21207   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21208   # "foo.exe" is OK but "foo" is an error.
21209   #
21210   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21211   # It is also a way to make sure we got the proper file name for the real test later on.
21212   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21213   if test "x$test_shortpath" = x; then
21214     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21215 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21216     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21217   fi
21218 
21219   # Call helper function which possibly converts this using DOS-style short mode.
21220   # If so, the updated path is stored in $new_path.
21221 
21222   input_path="$new_path"
21223   # Check if we need to convert this using DOS-style short mode. If the path
21224   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21225   # take no chances and rewrite it.
21226   # Note: m4 eats our [], so we need to use [ and ] instead.
21227   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21228   if test "x$has_forbidden_chars" != x; then
21229     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21230     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21231     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21232     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21233       # Going to short mode and back again did indeed matter. Since short mode is
21234       # case insensitive, let's make it lowercase to improve readability.
21235       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21236       # Now convert it back to Unix-stile (cygpath)
21237       input_path=`$CYGPATH -u "$shortmode_path"`
21238       new_path="$input_path"
21239     fi
21240   fi
21241 
21242   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21243   if test "x$test_cygdrive_prefix" = x; then
21244     # As a simple fix, exclude /usr/bin since it's not a real path.
21245     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21246       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21247       # a path prefixed by /cygdrive for fixpath to work.
21248       new_path="$CYGWIN_ROOT_PATH$input_path"
21249     fi
21250   fi
21251 
21252 
21253   if test "x$path" != "x$new_path"; then
21254     BOOT_JDK="$new_path"
21255     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21256 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21257   fi
21258 
21259     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21260 
21261   path="$BOOT_JDK"
21262   has_colon=`$ECHO $path | $GREP ^.:`
21263   new_path="$path"
21264   if test "x$has_colon" = x; then
21265     # Not in mixed or Windows style, start by that.
21266     new_path=`cmd //c echo $path`
21267   fi
21268 
21269 
21270   input_path="$new_path"
21271   # Check if we need to convert this using DOS-style short mode. If the path
21272   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21273   # take no chances and rewrite it.
21274   # Note: m4 eats our [], so we need to use [ and ] instead.
21275   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21276   if test "x$has_forbidden_chars" != x; then
21277     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21278     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21279   fi
21280 
21281 
21282   windows_path="$new_path"
21283   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21284     unix_path=`$CYGPATH -u "$windows_path"`
21285     new_path="$unix_path"
21286   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21287     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21288     new_path="$unix_path"
21289   fi
21290 
21291   if test "x$path" != "x$new_path"; then
21292     BOOT_JDK="$new_path"
21293     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21294 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21295   fi
21296 
21297   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21298   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21299 
21300     else
21301       # We're on a unix platform. Hooray! :)
21302       path="$BOOT_JDK"
21303       has_space=`$ECHO "$path" | $GREP " "`
21304       if test "x$has_space" != x; then
21305         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21306 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21307         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21308       fi
21309 
21310       # Use eval to expand a potential ~
21311       eval path="$path"
21312       if test ! -f "$path" && test ! -d "$path"; then
21313         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21314       fi
21315 
21316       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21317     fi
21318   fi
21319 
21320             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21321 $as_echo_n "checking for Boot JDK... " >&6; }
21322             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21323 $as_echo "$BOOT_JDK" >&6; }
21324             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21325 $as_echo_n "checking Boot JDK version... " >&6; }
21326             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21327             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21328 $as_echo "$BOOT_JDK_VERSION" >&6; }
21329           fi # end check jdk version
21330         fi # end check javac
21331       fi # end check java
21332     fi # end check boot jdk found
21333   fi
21334 
21335   fi
21336 
21337 
21338     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21339     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21340       # Do we have a bin/java?
21341       if test ! -x "$BOOT_JDK/bin/java"; then
21342         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21343 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21344         BOOT_JDK_FOUND=no
21345       else
21346         # Do we have a bin/javac?
21347         if test ! -x "$BOOT_JDK/bin/javac"; then
21348           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21349 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21350           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21351 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21352           BOOT_JDK_FOUND=no
21353         else
21354           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21355           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21356 
21357           # Extra M4 quote needed to protect [] in grep expression.
21358           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
21359           if test "x$FOUND_CORRECT_VERSION" = x; then
21360             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21361 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21362             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21363 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21364             BOOT_JDK_FOUND=no
21365           else
21366             # We're done! :-)
21367             BOOT_JDK_FOUND=yes
21368 
21369   # Only process if variable expands to non-empty
21370 
21371   if test "x$BOOT_JDK" != x; then
21372     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21373 
21374   # Input might be given as Windows format, start by converting to
21375   # unix format.
21376   path="$BOOT_JDK"
21377   new_path=`$CYGPATH -u "$path"`
21378 
21379   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21380   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21381   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21382   # "foo.exe" is OK but "foo" is an error.
21383   #
21384   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21385   # It is also a way to make sure we got the proper file name for the real test later on.
21386   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21387   if test "x$test_shortpath" = x; then
21388     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21389 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21390     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21391   fi
21392 
21393   # Call helper function which possibly converts this using DOS-style short mode.
21394   # If so, the updated path is stored in $new_path.
21395 
21396   input_path="$new_path"
21397   # Check if we need to convert this using DOS-style short mode. If the path
21398   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21399   # take no chances and rewrite it.
21400   # Note: m4 eats our [], so we need to use [ and ] instead.
21401   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21402   if test "x$has_forbidden_chars" != x; then
21403     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21404     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21405     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21406     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21407       # Going to short mode and back again did indeed matter. Since short mode is
21408       # case insensitive, let's make it lowercase to improve readability.
21409       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21410       # Now convert it back to Unix-stile (cygpath)
21411       input_path=`$CYGPATH -u "$shortmode_path"`
21412       new_path="$input_path"
21413     fi
21414   fi
21415 
21416   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21417   if test "x$test_cygdrive_prefix" = x; then
21418     # As a simple fix, exclude /usr/bin since it's not a real path.
21419     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21420       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21421       # a path prefixed by /cygdrive for fixpath to work.
21422       new_path="$CYGWIN_ROOT_PATH$input_path"
21423     fi
21424   fi
21425 
21426 
21427   if test "x$path" != "x$new_path"; then
21428     BOOT_JDK="$new_path"
21429     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21430 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21431   fi
21432 
21433     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21434 
21435   path="$BOOT_JDK"
21436   has_colon=`$ECHO $path | $GREP ^.:`
21437   new_path="$path"
21438   if test "x$has_colon" = x; then
21439     # Not in mixed or Windows style, start by that.
21440     new_path=`cmd //c echo $path`
21441   fi
21442 
21443 
21444   input_path="$new_path"
21445   # Check if we need to convert this using DOS-style short mode. If the path
21446   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21447   # take no chances and rewrite it.
21448   # Note: m4 eats our [], so we need to use [ and ] instead.
21449   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21450   if test "x$has_forbidden_chars" != x; then
21451     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21452     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21453   fi
21454 
21455 
21456   windows_path="$new_path"
21457   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21458     unix_path=`$CYGPATH -u "$windows_path"`
21459     new_path="$unix_path"
21460   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21461     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21462     new_path="$unix_path"
21463   fi
21464 
21465   if test "x$path" != "x$new_path"; then
21466     BOOT_JDK="$new_path"
21467     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21468 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21469   fi
21470 
21471   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21472   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21473 
21474     else
21475       # We're on a unix platform. Hooray! :)
21476       path="$BOOT_JDK"
21477       has_space=`$ECHO "$path" | $GREP " "`
21478       if test "x$has_space" != x; then
21479         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21480 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21481         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21482       fi
21483 
21484       # Use eval to expand a potential ~
21485       eval path="$path"
21486       if test ! -f "$path" && test ! -d "$path"; then
21487         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21488       fi
21489 
21490       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21491     fi
21492   fi
21493 
21494             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21495 $as_echo_n "checking for Boot JDK... " >&6; }
21496             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21497 $as_echo "$BOOT_JDK" >&6; }
21498             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21499 $as_echo_n "checking Boot JDK version... " >&6; }
21500             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21501             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21502 $as_echo "$BOOT_JDK_VERSION" >&6; }
21503           fi # end check jdk version
21504         fi # end check javac
21505       fi # end check java
21506     fi # end check boot jdk found
21507   fi
21508 
21509 
21510   # Test: Is $JAVA_HOME set?
21511 
21512   if test "x$BOOT_JDK_FOUND" = xno; then
21513     # Now execute the test
21514 
21515   if test "x$JAVA_HOME" != x; then
21516     JAVA_HOME_PROCESSED="$JAVA_HOME"
21517 
21518   # Only process if variable expands to non-empty
21519 
21520   if test "x$JAVA_HOME_PROCESSED" != x; then
21521     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21522 
21523   # Input might be given as Windows format, start by converting to
21524   # unix format.
21525   path="$JAVA_HOME_PROCESSED"
21526   new_path=`$CYGPATH -u "$path"`
21527 
21528   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21529   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21530   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21531   # "foo.exe" is OK but "foo" is an error.
21532   #
21533   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21534   # It is also a way to make sure we got the proper file name for the real test later on.
21535   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21536   if test "x$test_shortpath" = x; then
21537     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
21538 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
21539     as_fn_error $? "Cannot locate the the path of JAVA_HOME_PROCESSED" "$LINENO" 5
21540   fi
21541 
21542   # Call helper function which possibly converts this using DOS-style short mode.
21543   # If so, the updated path is stored in $new_path.
21544 
21545   input_path="$new_path"
21546   # Check if we need to convert this using DOS-style short mode. If the path
21547   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21548   # take no chances and rewrite it.
21549   # Note: m4 eats our [], so we need to use [ and ] instead.
21550   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21551   if test "x$has_forbidden_chars" != x; then
21552     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21553     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21554     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21555     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21556       # Going to short mode and back again did indeed matter. Since short mode is
21557       # case insensitive, let's make it lowercase to improve readability.
21558       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21559       # Now convert it back to Unix-stile (cygpath)
21560       input_path=`$CYGPATH -u "$shortmode_path"`
21561       new_path="$input_path"
21562     fi
21563   fi
21564 
21565   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21566   if test "x$test_cygdrive_prefix" = x; then
21567     # As a simple fix, exclude /usr/bin since it's not a real path.
21568     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21569       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21570       # a path prefixed by /cygdrive for fixpath to work.
21571       new_path="$CYGWIN_ROOT_PATH$input_path"
21572     fi
21573   fi
21574 
21575 
21576   if test "x$path" != "x$new_path"; then
21577     JAVA_HOME_PROCESSED="$new_path"
21578     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
21579 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
21580   fi
21581 
21582     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21583 
21584   path="$JAVA_HOME_PROCESSED"
21585   has_colon=`$ECHO $path | $GREP ^.:`
21586   new_path="$path"
21587   if test "x$has_colon" = x; then
21588     # Not in mixed or Windows style, start by that.
21589     new_path=`cmd //c echo $path`
21590   fi
21591 
21592 
21593   input_path="$new_path"
21594   # Check if we need to convert this using DOS-style short mode. If the path
21595   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21596   # take no chances and rewrite it.
21597   # Note: m4 eats our [], so we need to use [ and ] instead.
21598   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21599   if test "x$has_forbidden_chars" != x; then
21600     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21601     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21602   fi
21603 
21604 
21605   windows_path="$new_path"
21606   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21607     unix_path=`$CYGPATH -u "$windows_path"`
21608     new_path="$unix_path"
21609   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21610     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21611     new_path="$unix_path"
21612   fi
21613 
21614   if test "x$path" != "x$new_path"; then
21615     JAVA_HOME_PROCESSED="$new_path"
21616     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
21617 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
21618   fi
21619 
21620   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21621   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21622 
21623     else
21624       # We're on a unix platform. Hooray! :)
21625       path="$JAVA_HOME_PROCESSED"
21626       has_space=`$ECHO "$path" | $GREP " "`
21627       if test "x$has_space" != x; then
21628         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
21629 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
21630         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21631       fi
21632 
21633       # Use eval to expand a potential ~
21634       eval path="$path"
21635       if test ! -f "$path" && test ! -d "$path"; then
21636         as_fn_error $? "The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is not found." "$LINENO" 5
21637       fi
21638 
21639       JAVA_HOME_PROCESSED="`cd "$path"; $THEPWDCMD -L`"
21640     fi
21641   fi
21642 
21643     if test ! -d "$JAVA_HOME_PROCESSED"; then
21644       { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
21645 $as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
21646     else
21647       # Aha, the user has set a JAVA_HOME
21648       # let us use that as the Boot JDK.
21649       BOOT_JDK="$JAVA_HOME_PROCESSED"
21650       BOOT_JDK_FOUND=maybe
21651       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using JAVA_HOME" >&5
21652 $as_echo "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
21653     fi
21654   fi
21655 
21656 
21657     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21658     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21659       # Do we have a bin/java?
21660       if test ! -x "$BOOT_JDK/bin/java"; then
21661         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21662 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21663         BOOT_JDK_FOUND=no
21664       else
21665         # Do we have a bin/javac?
21666         if test ! -x "$BOOT_JDK/bin/javac"; then
21667           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21668 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21669           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21670 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21671           BOOT_JDK_FOUND=no
21672         else
21673           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21674           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21675 
21676           # Extra M4 quote needed to protect [] in grep expression.
21677           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
21678           if test "x$FOUND_CORRECT_VERSION" = x; then
21679             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21680 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21681             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21682 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21683             BOOT_JDK_FOUND=no
21684           else
21685             # We're done! :-)
21686             BOOT_JDK_FOUND=yes
21687 
21688   # Only process if variable expands to non-empty
21689 
21690   if test "x$BOOT_JDK" != x; then
21691     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21692 
21693   # Input might be given as Windows format, start by converting to
21694   # unix format.
21695   path="$BOOT_JDK"
21696   new_path=`$CYGPATH -u "$path"`
21697 
21698   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21699   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21700   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21701   # "foo.exe" is OK but "foo" is an error.
21702   #
21703   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21704   # It is also a way to make sure we got the proper file name for the real test later on.
21705   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21706   if test "x$test_shortpath" = x; then
21707     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21708 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21709     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21710   fi
21711 
21712   # Call helper function which possibly converts this using DOS-style short mode.
21713   # If so, the updated path is stored in $new_path.
21714 
21715   input_path="$new_path"
21716   # Check if we need to convert this using DOS-style short mode. If the path
21717   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21718   # take no chances and rewrite it.
21719   # Note: m4 eats our [], so we need to use [ and ] instead.
21720   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21721   if test "x$has_forbidden_chars" != x; then
21722     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21723     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21724     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21725     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21726       # Going to short mode and back again did indeed matter. Since short mode is
21727       # case insensitive, let's make it lowercase to improve readability.
21728       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21729       # Now convert it back to Unix-stile (cygpath)
21730       input_path=`$CYGPATH -u "$shortmode_path"`
21731       new_path="$input_path"
21732     fi
21733   fi
21734 
21735   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21736   if test "x$test_cygdrive_prefix" = x; then
21737     # As a simple fix, exclude /usr/bin since it's not a real path.
21738     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21739       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21740       # a path prefixed by /cygdrive for fixpath to work.
21741       new_path="$CYGWIN_ROOT_PATH$input_path"
21742     fi
21743   fi
21744 
21745 
21746   if test "x$path" != "x$new_path"; then
21747     BOOT_JDK="$new_path"
21748     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21749 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21750   fi
21751 
21752     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21753 
21754   path="$BOOT_JDK"
21755   has_colon=`$ECHO $path | $GREP ^.:`
21756   new_path="$path"
21757   if test "x$has_colon" = x; then
21758     # Not in mixed or Windows style, start by that.
21759     new_path=`cmd //c echo $path`
21760   fi
21761 
21762 
21763   input_path="$new_path"
21764   # Check if we need to convert this using DOS-style short mode. If the path
21765   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21766   # take no chances and rewrite it.
21767   # Note: m4 eats our [], so we need to use [ and ] instead.
21768   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21769   if test "x$has_forbidden_chars" != x; then
21770     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21771     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21772   fi
21773 
21774 
21775   windows_path="$new_path"
21776   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21777     unix_path=`$CYGPATH -u "$windows_path"`
21778     new_path="$unix_path"
21779   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21780     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21781     new_path="$unix_path"
21782   fi
21783 
21784   if test "x$path" != "x$new_path"; then
21785     BOOT_JDK="$new_path"
21786     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21787 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21788   fi
21789 
21790   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21791   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21792 
21793     else
21794       # We're on a unix platform. Hooray! :)
21795       path="$BOOT_JDK"
21796       has_space=`$ECHO "$path" | $GREP " "`
21797       if test "x$has_space" != x; then
21798         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21799 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21800         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21801       fi
21802 
21803       # Use eval to expand a potential ~
21804       eval path="$path"
21805       if test ! -f "$path" && test ! -d "$path"; then
21806         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21807       fi
21808 
21809       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21810     fi
21811   fi
21812 
21813             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21814 $as_echo_n "checking for Boot JDK... " >&6; }
21815             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21816 $as_echo "$BOOT_JDK" >&6; }
21817             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21818 $as_echo_n "checking Boot JDK version... " >&6; }
21819             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21820             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21821 $as_echo "$BOOT_JDK_VERSION" >&6; }
21822           fi # end check jdk version
21823         fi # end check javac
21824       fi # end check java
21825     fi # end check boot jdk found
21826   fi
21827 
21828 
21829   # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
21830 
21831   if test "x$BOOT_JDK_FOUND" = xno; then
21832     # Now execute the test
21833 
21834   # Extract the first word of "javac", so it can be a program name with args.
21835 set dummy javac; ac_word=$2
21836 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21837 $as_echo_n "checking for $ac_word... " >&6; }
21838 if ${ac_cv_path_JAVAC_CHECK+:} false; then :
21839   $as_echo_n "(cached) " >&6
21840 else
21841   case $JAVAC_CHECK in
21842   [\\/]* | ?:[\\/]*)
21843   ac_cv_path_JAVAC_CHECK="$JAVAC_CHECK" # Let the user override the test with a path.
21844   ;;
21845   *)
21846   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21847 for as_dir in $PATH
21848 do
21849   IFS=$as_save_IFS
21850   test -z "$as_dir" && as_dir=.
21851     for ac_exec_ext in '' $ac_executable_extensions; do
21852   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21853     ac_cv_path_JAVAC_CHECK="$as_dir/$ac_word$ac_exec_ext"
21854     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21855     break 2
21856   fi
21857 done
21858   done
21859 IFS=$as_save_IFS
21860 
21861   ;;
21862 esac
21863 fi
21864 JAVAC_CHECK=$ac_cv_path_JAVAC_CHECK
21865 if test -n "$JAVAC_CHECK"; then
21866   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5
21867 $as_echo "$JAVAC_CHECK" >&6; }
21868 else
21869   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21870 $as_echo "no" >&6; }
21871 fi
21872 
21873 
21874   # Extract the first word of "java", so it can be a program name with args.
21875 set dummy java; ac_word=$2
21876 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21877 $as_echo_n "checking for $ac_word... " >&6; }
21878 if ${ac_cv_path_JAVA_CHECK+:} false; then :
21879   $as_echo_n "(cached) " >&6
21880 else
21881   case $JAVA_CHECK in
21882   [\\/]* | ?:[\\/]*)
21883   ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path.
21884   ;;
21885   *)
21886   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21887 for as_dir in $PATH
21888 do
21889   IFS=$as_save_IFS
21890   test -z "$as_dir" && as_dir=.
21891     for ac_exec_ext in '' $ac_executable_extensions; do
21892   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21893     ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext"
21894     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21895     break 2
21896   fi
21897 done
21898   done
21899 IFS=$as_save_IFS
21900 
21901   ;;
21902 esac
21903 fi
21904 JAVA_CHECK=$ac_cv_path_JAVA_CHECK
21905 if test -n "$JAVA_CHECK"; then
21906   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5
21907 $as_echo "$JAVA_CHECK" >&6; }
21908 else
21909   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21910 $as_echo "no" >&6; }
21911 fi
21912 
21913 
21914   BINARY="$JAVAC_CHECK"
21915   if test "x$JAVAC_CHECK" = x; then
21916     BINARY="$JAVA_CHECK"
21917   fi
21918   if test "x$BINARY" != x; then
21919     # So there is a java(c) binary, it might be part of a JDK.
21920     # Lets find the JDK/JRE directory by following symbolic links.
21921     # Linux/GNU systems often have links from /usr/bin/java to
21922     # /etc/alternatives/java to the real JDK binary.
21923 
21924   if test "x$OPENJDK_BUILD_OS" != xwindows; then
21925     # Follow a chain of symbolic links. Use readlink
21926     # where it exists, else fall back to horribly
21927     # complicated shell code.
21928     if test "x$READLINK_TESTED" != yes; then
21929       # On MacOSX there is a readlink tool with a different
21930       # purpose than the GNU readlink tool. Check the found readlink.
21931       ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
21932       if test "x$ISGNU" = x; then
21933         # A readlink that we do not know how to use.
21934         # Are there other non-GNU readlinks out there?
21935         READLINK_TESTED=yes
21936         READLINK=
21937       fi
21938     fi
21939 
21940     if test "x$READLINK" != x; then
21941       BINARY=`$READLINK -f $BINARY`
21942     else
21943       # Save the current directory for restoring afterwards
21944       STARTDIR=$PWD
21945       COUNTER=0
21946       sym_link_dir=`$DIRNAME $BINARY`
21947       sym_link_file=`$BASENAME $BINARY`
21948       cd $sym_link_dir
21949       # Use -P flag to resolve symlinks in directories.
21950       cd `$THEPWDCMD -P`
21951       sym_link_dir=`$THEPWDCMD -P`
21952       # Resolve file symlinks
21953       while test $COUNTER -lt 20; do
21954         ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
21955         if test "x$ISLINK" == x; then
21956           # This is not a symbolic link! We are done!
21957           break
21958         fi
21959         # Again resolve directory symlinks since the target of the just found
21960         # link could be in a different directory
21961         cd `$DIRNAME $ISLINK`
21962         sym_link_dir=`$THEPWDCMD -P`
21963         sym_link_file=`$BASENAME $ISLINK`
21964         let COUNTER=COUNTER+1
21965       done
21966       cd $STARTDIR
21967       BINARY=$sym_link_dir/$sym_link_file
21968     fi
21969   fi
21970 
21971     BOOT_JDK=`dirname "$BINARY"`
21972     BOOT_JDK=`cd "$BOOT_JDK/.."; pwd`
21973     if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then
21974       # Looks like we found ourselves an JDK
21975       BOOT_JDK_FOUND=maybe
21976       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using java(c) in PATH" >&5
21977 $as_echo "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
21978     fi
21979   fi
21980 
21981 
21982     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21983     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21984       # Do we have a bin/java?
21985       if test ! -x "$BOOT_JDK/bin/java"; then
21986         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21987 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21988         BOOT_JDK_FOUND=no
21989       else
21990         # Do we have a bin/javac?
21991         if test ! -x "$BOOT_JDK/bin/javac"; then
21992           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21993 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21994           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21995 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21996           BOOT_JDK_FOUND=no
21997         else
21998           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21999           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22000 
22001           # Extra M4 quote needed to protect [] in grep expression.
22002           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22003           if test "x$FOUND_CORRECT_VERSION" = x; then
22004             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22005 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22006             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22007 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22008             BOOT_JDK_FOUND=no
22009           else
22010             # We're done! :-)
22011             BOOT_JDK_FOUND=yes
22012 
22013   # Only process if variable expands to non-empty
22014 
22015   if test "x$BOOT_JDK" != x; then
22016     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22017 
22018   # Input might be given as Windows format, start by converting to
22019   # unix format.
22020   path="$BOOT_JDK"
22021   new_path=`$CYGPATH -u "$path"`
22022 
22023   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22024   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22025   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22026   # "foo.exe" is OK but "foo" is an error.
22027   #
22028   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22029   # It is also a way to make sure we got the proper file name for the real test later on.
22030   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22031   if test "x$test_shortpath" = x; then
22032     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22033 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22034     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22035   fi
22036 
22037   # Call helper function which possibly converts this using DOS-style short mode.
22038   # If so, the updated path is stored in $new_path.
22039 
22040   input_path="$new_path"
22041   # Check if we need to convert this using DOS-style short mode. If the path
22042   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22043   # take no chances and rewrite it.
22044   # Note: m4 eats our [], so we need to use [ and ] instead.
22045   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22046   if test "x$has_forbidden_chars" != x; then
22047     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22048     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22049     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22050     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22051       # Going to short mode and back again did indeed matter. Since short mode is
22052       # case insensitive, let's make it lowercase to improve readability.
22053       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22054       # Now convert it back to Unix-stile (cygpath)
22055       input_path=`$CYGPATH -u "$shortmode_path"`
22056       new_path="$input_path"
22057     fi
22058   fi
22059 
22060   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22061   if test "x$test_cygdrive_prefix" = x; then
22062     # As a simple fix, exclude /usr/bin since it's not a real path.
22063     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22064       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22065       # a path prefixed by /cygdrive for fixpath to work.
22066       new_path="$CYGWIN_ROOT_PATH$input_path"
22067     fi
22068   fi
22069 
22070 
22071   if test "x$path" != "x$new_path"; then
22072     BOOT_JDK="$new_path"
22073     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22074 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22075   fi
22076 
22077     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22078 
22079   path="$BOOT_JDK"
22080   has_colon=`$ECHO $path | $GREP ^.:`
22081   new_path="$path"
22082   if test "x$has_colon" = x; then
22083     # Not in mixed or Windows style, start by that.
22084     new_path=`cmd //c echo $path`
22085   fi
22086 
22087 
22088   input_path="$new_path"
22089   # Check if we need to convert this using DOS-style short mode. If the path
22090   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22091   # take no chances and rewrite it.
22092   # Note: m4 eats our [], so we need to use [ and ] instead.
22093   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22094   if test "x$has_forbidden_chars" != x; then
22095     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22096     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22097   fi
22098 
22099 
22100   windows_path="$new_path"
22101   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22102     unix_path=`$CYGPATH -u "$windows_path"`
22103     new_path="$unix_path"
22104   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22105     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22106     new_path="$unix_path"
22107   fi
22108 
22109   if test "x$path" != "x$new_path"; then
22110     BOOT_JDK="$new_path"
22111     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22112 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22113   fi
22114 
22115   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22116   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22117 
22118     else
22119       # We're on a unix platform. Hooray! :)
22120       path="$BOOT_JDK"
22121       has_space=`$ECHO "$path" | $GREP " "`
22122       if test "x$has_space" != x; then
22123         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22124 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22125         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22126       fi
22127 
22128       # Use eval to expand a potential ~
22129       eval path="$path"
22130       if test ! -f "$path" && test ! -d "$path"; then
22131         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22132       fi
22133 
22134       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22135     fi
22136   fi
22137 
22138             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22139 $as_echo_n "checking for Boot JDK... " >&6; }
22140             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22141 $as_echo "$BOOT_JDK" >&6; }
22142             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22143 $as_echo_n "checking Boot JDK version... " >&6; }
22144             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22145             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22146 $as_echo "$BOOT_JDK_VERSION" >&6; }
22147           fi # end check jdk version
22148         fi # end check javac
22149       fi # end check java
22150     fi # end check boot jdk found
22151   fi
22152 
22153 
22154   # Test: Is there a JDK installed in default, well-known locations?
22155 
22156   if test "x$BOOT_JDK_FOUND" = xno; then
22157     # Now execute the test
22158 
22159   if test "x$OPENJDK_TARGET_OS" = xwindows; then
22160 
22161   if test "x$BOOT_JDK_FOUND" = xno; then
22162     # Now execute the test
22163 
22164   if test "x$ProgramW6432" != x; then
22165     VIRTUAL_DIR="$ProgramW6432/Java"
22166 
22167   windows_path="$VIRTUAL_DIR"
22168   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22169     unix_path=`$CYGPATH -u "$windows_path"`
22170     VIRTUAL_DIR="$unix_path"
22171   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22172     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22173     VIRTUAL_DIR="$unix_path"
22174   fi
22175 
22176 
22177   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22178   BOOT_JDK_SUFFIX=""
22179   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22180   if test "x$ALL_JDKS_FOUND" != x; then
22181     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22182 
22183   if test "x$BOOT_JDK_FOUND" = xno; then
22184     # Now execute the test
22185 
22186         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22187         if test -d "$BOOT_JDK"; then
22188           BOOT_JDK_FOUND=maybe
22189           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22190 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22191         fi
22192 
22193 
22194     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22195     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22196       # Do we have a bin/java?
22197       if test ! -x "$BOOT_JDK/bin/java"; then
22198         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22199 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22200         BOOT_JDK_FOUND=no
22201       else
22202         # Do we have a bin/javac?
22203         if test ! -x "$BOOT_JDK/bin/javac"; then
22204           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22205 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22206           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22207 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22208           BOOT_JDK_FOUND=no
22209         else
22210           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22211           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22212 
22213           # Extra M4 quote needed to protect [] in grep expression.
22214           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22215           if test "x$FOUND_CORRECT_VERSION" = x; then
22216             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22217 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22218             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22219 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22220             BOOT_JDK_FOUND=no
22221           else
22222             # We're done! :-)
22223             BOOT_JDK_FOUND=yes
22224 
22225   # Only process if variable expands to non-empty
22226 
22227   if test "x$BOOT_JDK" != x; then
22228     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22229 
22230   # Input might be given as Windows format, start by converting to
22231   # unix format.
22232   path="$BOOT_JDK"
22233   new_path=`$CYGPATH -u "$path"`
22234 
22235   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22236   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22237   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22238   # "foo.exe" is OK but "foo" is an error.
22239   #
22240   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22241   # It is also a way to make sure we got the proper file name for the real test later on.
22242   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22243   if test "x$test_shortpath" = x; then
22244     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22245 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22246     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22247   fi
22248 
22249   # Call helper function which possibly converts this using DOS-style short mode.
22250   # If so, the updated path is stored in $new_path.
22251 
22252   input_path="$new_path"
22253   # Check if we need to convert this using DOS-style short mode. If the path
22254   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22255   # take no chances and rewrite it.
22256   # Note: m4 eats our [], so we need to use [ and ] instead.
22257   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22258   if test "x$has_forbidden_chars" != x; then
22259     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22260     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22261     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22262     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22263       # Going to short mode and back again did indeed matter. Since short mode is
22264       # case insensitive, let's make it lowercase to improve readability.
22265       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22266       # Now convert it back to Unix-stile (cygpath)
22267       input_path=`$CYGPATH -u "$shortmode_path"`
22268       new_path="$input_path"
22269     fi
22270   fi
22271 
22272   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22273   if test "x$test_cygdrive_prefix" = x; then
22274     # As a simple fix, exclude /usr/bin since it's not a real path.
22275     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22276       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22277       # a path prefixed by /cygdrive for fixpath to work.
22278       new_path="$CYGWIN_ROOT_PATH$input_path"
22279     fi
22280   fi
22281 
22282 
22283   if test "x$path" != "x$new_path"; then
22284     BOOT_JDK="$new_path"
22285     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22286 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22287   fi
22288 
22289     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22290 
22291   path="$BOOT_JDK"
22292   has_colon=`$ECHO $path | $GREP ^.:`
22293   new_path="$path"
22294   if test "x$has_colon" = x; then
22295     # Not in mixed or Windows style, start by that.
22296     new_path=`cmd //c echo $path`
22297   fi
22298 
22299 
22300   input_path="$new_path"
22301   # Check if we need to convert this using DOS-style short mode. If the path
22302   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22303   # take no chances and rewrite it.
22304   # Note: m4 eats our [], so we need to use [ and ] instead.
22305   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22306   if test "x$has_forbidden_chars" != x; then
22307     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22308     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22309   fi
22310 
22311 
22312   windows_path="$new_path"
22313   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22314     unix_path=`$CYGPATH -u "$windows_path"`
22315     new_path="$unix_path"
22316   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22317     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22318     new_path="$unix_path"
22319   fi
22320 
22321   if test "x$path" != "x$new_path"; then
22322     BOOT_JDK="$new_path"
22323     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22324 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22325   fi
22326 
22327   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22328   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22329 
22330     else
22331       # We're on a unix platform. Hooray! :)
22332       path="$BOOT_JDK"
22333       has_space=`$ECHO "$path" | $GREP " "`
22334       if test "x$has_space" != x; then
22335         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22336 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22337         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22338       fi
22339 
22340       # Use eval to expand a potential ~
22341       eval path="$path"
22342       if test ! -f "$path" && test ! -d "$path"; then
22343         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22344       fi
22345 
22346       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22347     fi
22348   fi
22349 
22350             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22351 $as_echo_n "checking for Boot JDK... " >&6; }
22352             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22353 $as_echo "$BOOT_JDK" >&6; }
22354             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22355 $as_echo_n "checking Boot JDK version... " >&6; }
22356             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22357             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22358 $as_echo "$BOOT_JDK_VERSION" >&6; }
22359           fi # end check jdk version
22360         fi # end check javac
22361       fi # end check java
22362     fi # end check boot jdk found
22363   fi
22364 
22365     done
22366   fi
22367 
22368   fi
22369 
22370 
22371     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22372     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22373       # Do we have a bin/java?
22374       if test ! -x "$BOOT_JDK/bin/java"; then
22375         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22376 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22377         BOOT_JDK_FOUND=no
22378       else
22379         # Do we have a bin/javac?
22380         if test ! -x "$BOOT_JDK/bin/javac"; then
22381           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22382 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22383           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22384 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22385           BOOT_JDK_FOUND=no
22386         else
22387           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22388           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22389 
22390           # Extra M4 quote needed to protect [] in grep expression.
22391           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22392           if test "x$FOUND_CORRECT_VERSION" = x; then
22393             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22394 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22395             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22396 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22397             BOOT_JDK_FOUND=no
22398           else
22399             # We're done! :-)
22400             BOOT_JDK_FOUND=yes
22401 
22402   # Only process if variable expands to non-empty
22403 
22404   if test "x$BOOT_JDK" != x; then
22405     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22406 
22407   # Input might be given as Windows format, start by converting to
22408   # unix format.
22409   path="$BOOT_JDK"
22410   new_path=`$CYGPATH -u "$path"`
22411 
22412   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22413   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22414   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22415   # "foo.exe" is OK but "foo" is an error.
22416   #
22417   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22418   # It is also a way to make sure we got the proper file name for the real test later on.
22419   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22420   if test "x$test_shortpath" = x; then
22421     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22422 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22423     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22424   fi
22425 
22426   # Call helper function which possibly converts this using DOS-style short mode.
22427   # If so, the updated path is stored in $new_path.
22428 
22429   input_path="$new_path"
22430   # Check if we need to convert this using DOS-style short mode. If the path
22431   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22432   # take no chances and rewrite it.
22433   # Note: m4 eats our [], so we need to use [ and ] instead.
22434   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22435   if test "x$has_forbidden_chars" != x; then
22436     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22437     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22438     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22439     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22440       # Going to short mode and back again did indeed matter. Since short mode is
22441       # case insensitive, let's make it lowercase to improve readability.
22442       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22443       # Now convert it back to Unix-stile (cygpath)
22444       input_path=`$CYGPATH -u "$shortmode_path"`
22445       new_path="$input_path"
22446     fi
22447   fi
22448 
22449   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22450   if test "x$test_cygdrive_prefix" = x; then
22451     # As a simple fix, exclude /usr/bin since it's not a real path.
22452     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22453       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22454       # a path prefixed by /cygdrive for fixpath to work.
22455       new_path="$CYGWIN_ROOT_PATH$input_path"
22456     fi
22457   fi
22458 
22459 
22460   if test "x$path" != "x$new_path"; then
22461     BOOT_JDK="$new_path"
22462     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22463 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22464   fi
22465 
22466     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22467 
22468   path="$BOOT_JDK"
22469   has_colon=`$ECHO $path | $GREP ^.:`
22470   new_path="$path"
22471   if test "x$has_colon" = x; then
22472     # Not in mixed or Windows style, start by that.
22473     new_path=`cmd //c echo $path`
22474   fi
22475 
22476 
22477   input_path="$new_path"
22478   # Check if we need to convert this using DOS-style short mode. If the path
22479   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22480   # take no chances and rewrite it.
22481   # Note: m4 eats our [], so we need to use [ and ] instead.
22482   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22483   if test "x$has_forbidden_chars" != x; then
22484     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22485     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22486   fi
22487 
22488 
22489   windows_path="$new_path"
22490   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22491     unix_path=`$CYGPATH -u "$windows_path"`
22492     new_path="$unix_path"
22493   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22494     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22495     new_path="$unix_path"
22496   fi
22497 
22498   if test "x$path" != "x$new_path"; then
22499     BOOT_JDK="$new_path"
22500     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22501 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22502   fi
22503 
22504   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22505   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22506 
22507     else
22508       # We're on a unix platform. Hooray! :)
22509       path="$BOOT_JDK"
22510       has_space=`$ECHO "$path" | $GREP " "`
22511       if test "x$has_space" != x; then
22512         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22513 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22514         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22515       fi
22516 
22517       # Use eval to expand a potential ~
22518       eval path="$path"
22519       if test ! -f "$path" && test ! -d "$path"; then
22520         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22521       fi
22522 
22523       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22524     fi
22525   fi
22526 
22527             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22528 $as_echo_n "checking for Boot JDK... " >&6; }
22529             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22530 $as_echo "$BOOT_JDK" >&6; }
22531             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22532 $as_echo_n "checking Boot JDK version... " >&6; }
22533             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22534             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22535 $as_echo "$BOOT_JDK_VERSION" >&6; }
22536           fi # end check jdk version
22537         fi # end check javac
22538       fi # end check java
22539     fi # end check boot jdk found
22540   fi
22541 
22542 
22543   if test "x$BOOT_JDK_FOUND" = xno; then
22544     # Now execute the test
22545 
22546   if test "x$PROGRAMW6432" != x; then
22547     VIRTUAL_DIR="$PROGRAMW6432/Java"
22548 
22549   windows_path="$VIRTUAL_DIR"
22550   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22551     unix_path=`$CYGPATH -u "$windows_path"`
22552     VIRTUAL_DIR="$unix_path"
22553   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22554     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22555     VIRTUAL_DIR="$unix_path"
22556   fi
22557 
22558 
22559   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22560   BOOT_JDK_SUFFIX=""
22561   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22562   if test "x$ALL_JDKS_FOUND" != x; then
22563     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22564 
22565   if test "x$BOOT_JDK_FOUND" = xno; then
22566     # Now execute the test
22567 
22568         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22569         if test -d "$BOOT_JDK"; then
22570           BOOT_JDK_FOUND=maybe
22571           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22572 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22573         fi
22574 
22575 
22576     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22577     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22578       # Do we have a bin/java?
22579       if test ! -x "$BOOT_JDK/bin/java"; then
22580         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22581 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22582         BOOT_JDK_FOUND=no
22583       else
22584         # Do we have a bin/javac?
22585         if test ! -x "$BOOT_JDK/bin/javac"; then
22586           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22587 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22588           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22589 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22590           BOOT_JDK_FOUND=no
22591         else
22592           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22593           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22594 
22595           # Extra M4 quote needed to protect [] in grep expression.
22596           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22597           if test "x$FOUND_CORRECT_VERSION" = x; then
22598             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22599 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22600             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22601 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22602             BOOT_JDK_FOUND=no
22603           else
22604             # We're done! :-)
22605             BOOT_JDK_FOUND=yes
22606 
22607   # Only process if variable expands to non-empty
22608 
22609   if test "x$BOOT_JDK" != x; then
22610     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22611 
22612   # Input might be given as Windows format, start by converting to
22613   # unix format.
22614   path="$BOOT_JDK"
22615   new_path=`$CYGPATH -u "$path"`
22616 
22617   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22618   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22619   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22620   # "foo.exe" is OK but "foo" is an error.
22621   #
22622   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22623   # It is also a way to make sure we got the proper file name for the real test later on.
22624   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22625   if test "x$test_shortpath" = x; then
22626     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22627 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22628     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22629   fi
22630 
22631   # Call helper function which possibly converts this using DOS-style short mode.
22632   # If so, the updated path is stored in $new_path.
22633 
22634   input_path="$new_path"
22635   # Check if we need to convert this using DOS-style short mode. If the path
22636   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22637   # take no chances and rewrite it.
22638   # Note: m4 eats our [], so we need to use [ and ] instead.
22639   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22640   if test "x$has_forbidden_chars" != x; then
22641     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22642     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22643     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22644     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22645       # Going to short mode and back again did indeed matter. Since short mode is
22646       # case insensitive, let's make it lowercase to improve readability.
22647       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22648       # Now convert it back to Unix-stile (cygpath)
22649       input_path=`$CYGPATH -u "$shortmode_path"`
22650       new_path="$input_path"
22651     fi
22652   fi
22653 
22654   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22655   if test "x$test_cygdrive_prefix" = x; then
22656     # As a simple fix, exclude /usr/bin since it's not a real path.
22657     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22658       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22659       # a path prefixed by /cygdrive for fixpath to work.
22660       new_path="$CYGWIN_ROOT_PATH$input_path"
22661     fi
22662   fi
22663 
22664 
22665   if test "x$path" != "x$new_path"; then
22666     BOOT_JDK="$new_path"
22667     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22668 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22669   fi
22670 
22671     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22672 
22673   path="$BOOT_JDK"
22674   has_colon=`$ECHO $path | $GREP ^.:`
22675   new_path="$path"
22676   if test "x$has_colon" = x; then
22677     # Not in mixed or Windows style, start by that.
22678     new_path=`cmd //c echo $path`
22679   fi
22680 
22681 
22682   input_path="$new_path"
22683   # Check if we need to convert this using DOS-style short mode. If the path
22684   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22685   # take no chances and rewrite it.
22686   # Note: m4 eats our [], so we need to use [ and ] instead.
22687   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22688   if test "x$has_forbidden_chars" != x; then
22689     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22690     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22691   fi
22692 
22693 
22694   windows_path="$new_path"
22695   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22696     unix_path=`$CYGPATH -u "$windows_path"`
22697     new_path="$unix_path"
22698   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22699     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22700     new_path="$unix_path"
22701   fi
22702 
22703   if test "x$path" != "x$new_path"; then
22704     BOOT_JDK="$new_path"
22705     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22706 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22707   fi
22708 
22709   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22710   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22711 
22712     else
22713       # We're on a unix platform. Hooray! :)
22714       path="$BOOT_JDK"
22715       has_space=`$ECHO "$path" | $GREP " "`
22716       if test "x$has_space" != x; then
22717         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22718 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22719         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22720       fi
22721 
22722       # Use eval to expand a potential ~
22723       eval path="$path"
22724       if test ! -f "$path" && test ! -d "$path"; then
22725         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22726       fi
22727 
22728       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22729     fi
22730   fi
22731 
22732             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22733 $as_echo_n "checking for Boot JDK... " >&6; }
22734             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22735 $as_echo "$BOOT_JDK" >&6; }
22736             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22737 $as_echo_n "checking Boot JDK version... " >&6; }
22738             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22739             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22740 $as_echo "$BOOT_JDK_VERSION" >&6; }
22741           fi # end check jdk version
22742         fi # end check javac
22743       fi # end check java
22744     fi # end check boot jdk found
22745   fi
22746 
22747     done
22748   fi
22749 
22750   fi
22751 
22752 
22753     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22754     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22755       # Do we have a bin/java?
22756       if test ! -x "$BOOT_JDK/bin/java"; then
22757         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22758 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22759         BOOT_JDK_FOUND=no
22760       else
22761         # Do we have a bin/javac?
22762         if test ! -x "$BOOT_JDK/bin/javac"; then
22763           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22764 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22765           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22766 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22767           BOOT_JDK_FOUND=no
22768         else
22769           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22770           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22771 
22772           # Extra M4 quote needed to protect [] in grep expression.
22773           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22774           if test "x$FOUND_CORRECT_VERSION" = x; then
22775             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22776 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22777             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22778 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22779             BOOT_JDK_FOUND=no
22780           else
22781             # We're done! :-)
22782             BOOT_JDK_FOUND=yes
22783 
22784   # Only process if variable expands to non-empty
22785 
22786   if test "x$BOOT_JDK" != x; then
22787     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22788 
22789   # Input might be given as Windows format, start by converting to
22790   # unix format.
22791   path="$BOOT_JDK"
22792   new_path=`$CYGPATH -u "$path"`
22793 
22794   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22795   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22796   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22797   # "foo.exe" is OK but "foo" is an error.
22798   #
22799   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22800   # It is also a way to make sure we got the proper file name for the real test later on.
22801   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22802   if test "x$test_shortpath" = x; then
22803     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22804 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22805     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22806   fi
22807 
22808   # Call helper function which possibly converts this using DOS-style short mode.
22809   # If so, the updated path is stored in $new_path.
22810 
22811   input_path="$new_path"
22812   # Check if we need to convert this using DOS-style short mode. If the path
22813   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22814   # take no chances and rewrite it.
22815   # Note: m4 eats our [], so we need to use [ and ] instead.
22816   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22817   if test "x$has_forbidden_chars" != x; then
22818     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22819     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22820     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22821     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22822       # Going to short mode and back again did indeed matter. Since short mode is
22823       # case insensitive, let's make it lowercase to improve readability.
22824       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22825       # Now convert it back to Unix-stile (cygpath)
22826       input_path=`$CYGPATH -u "$shortmode_path"`
22827       new_path="$input_path"
22828     fi
22829   fi
22830 
22831   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22832   if test "x$test_cygdrive_prefix" = x; then
22833     # As a simple fix, exclude /usr/bin since it's not a real path.
22834     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22835       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22836       # a path prefixed by /cygdrive for fixpath to work.
22837       new_path="$CYGWIN_ROOT_PATH$input_path"
22838     fi
22839   fi
22840 
22841 
22842   if test "x$path" != "x$new_path"; then
22843     BOOT_JDK="$new_path"
22844     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22845 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22846   fi
22847 
22848     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22849 
22850   path="$BOOT_JDK"
22851   has_colon=`$ECHO $path | $GREP ^.:`
22852   new_path="$path"
22853   if test "x$has_colon" = x; then
22854     # Not in mixed or Windows style, start by that.
22855     new_path=`cmd //c echo $path`
22856   fi
22857 
22858 
22859   input_path="$new_path"
22860   # Check if we need to convert this using DOS-style short mode. If the path
22861   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22862   # take no chances and rewrite it.
22863   # Note: m4 eats our [], so we need to use [ and ] instead.
22864   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22865   if test "x$has_forbidden_chars" != x; then
22866     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22867     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22868   fi
22869 
22870 
22871   windows_path="$new_path"
22872   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22873     unix_path=`$CYGPATH -u "$windows_path"`
22874     new_path="$unix_path"
22875   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22876     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22877     new_path="$unix_path"
22878   fi
22879 
22880   if test "x$path" != "x$new_path"; then
22881     BOOT_JDK="$new_path"
22882     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22883 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22884   fi
22885 
22886   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22887   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22888 
22889     else
22890       # We're on a unix platform. Hooray! :)
22891       path="$BOOT_JDK"
22892       has_space=`$ECHO "$path" | $GREP " "`
22893       if test "x$has_space" != x; then
22894         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22895 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22896         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22897       fi
22898 
22899       # Use eval to expand a potential ~
22900       eval path="$path"
22901       if test ! -f "$path" && test ! -d "$path"; then
22902         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22903       fi
22904 
22905       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22906     fi
22907   fi
22908 
22909             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22910 $as_echo_n "checking for Boot JDK... " >&6; }
22911             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22912 $as_echo "$BOOT_JDK" >&6; }
22913             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22914 $as_echo_n "checking Boot JDK version... " >&6; }
22915             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22916             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22917 $as_echo "$BOOT_JDK_VERSION" >&6; }
22918           fi # end check jdk version
22919         fi # end check javac
22920       fi # end check java
22921     fi # end check boot jdk found
22922   fi
22923 
22924 
22925   if test "x$BOOT_JDK_FOUND" = xno; then
22926     # Now execute the test
22927 
22928   if test "x$PROGRAMFILES" != x; then
22929     VIRTUAL_DIR="$PROGRAMFILES/Java"
22930 
22931   windows_path="$VIRTUAL_DIR"
22932   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22933     unix_path=`$CYGPATH -u "$windows_path"`
22934     VIRTUAL_DIR="$unix_path"
22935   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22936     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22937     VIRTUAL_DIR="$unix_path"
22938   fi
22939 
22940 
22941   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22942   BOOT_JDK_SUFFIX=""
22943   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22944   if test "x$ALL_JDKS_FOUND" != x; then
22945     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22946 
22947   if test "x$BOOT_JDK_FOUND" = xno; then
22948     # Now execute the test
22949 
22950         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22951         if test -d "$BOOT_JDK"; then
22952           BOOT_JDK_FOUND=maybe
22953           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22954 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22955         fi
22956 
22957 
22958     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22959     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22960       # Do we have a bin/java?
22961       if test ! -x "$BOOT_JDK/bin/java"; then
22962         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22963 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22964         BOOT_JDK_FOUND=no
22965       else
22966         # Do we have a bin/javac?
22967         if test ! -x "$BOOT_JDK/bin/javac"; then
22968           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22969 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22970           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22971 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22972           BOOT_JDK_FOUND=no
22973         else
22974           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22975           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22976 
22977           # Extra M4 quote needed to protect [] in grep expression.
22978           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22979           if test "x$FOUND_CORRECT_VERSION" = x; then
22980             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22981 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22982             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22983 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22984             BOOT_JDK_FOUND=no
22985           else
22986             # We're done! :-)
22987             BOOT_JDK_FOUND=yes
22988 
22989   # Only process if variable expands to non-empty
22990 
22991   if test "x$BOOT_JDK" != x; then
22992     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22993 
22994   # Input might be given as Windows format, start by converting to
22995   # unix format.
22996   path="$BOOT_JDK"
22997   new_path=`$CYGPATH -u "$path"`
22998 
22999   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23000   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23001   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23002   # "foo.exe" is OK but "foo" is an error.
23003   #
23004   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23005   # It is also a way to make sure we got the proper file name for the real test later on.
23006   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23007   if test "x$test_shortpath" = x; then
23008     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23009 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23010     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23011   fi
23012 
23013   # Call helper function which possibly converts this using DOS-style short mode.
23014   # If so, the updated path is stored in $new_path.
23015 
23016   input_path="$new_path"
23017   # Check if we need to convert this using DOS-style short mode. If the path
23018   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23019   # take no chances and rewrite it.
23020   # Note: m4 eats our [], so we need to use [ and ] instead.
23021   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23022   if test "x$has_forbidden_chars" != x; then
23023     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23024     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23025     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23026     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23027       # Going to short mode and back again did indeed matter. Since short mode is
23028       # case insensitive, let's make it lowercase to improve readability.
23029       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23030       # Now convert it back to Unix-stile (cygpath)
23031       input_path=`$CYGPATH -u "$shortmode_path"`
23032       new_path="$input_path"
23033     fi
23034   fi
23035 
23036   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23037   if test "x$test_cygdrive_prefix" = x; then
23038     # As a simple fix, exclude /usr/bin since it's not a real path.
23039     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23040       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23041       # a path prefixed by /cygdrive for fixpath to work.
23042       new_path="$CYGWIN_ROOT_PATH$input_path"
23043     fi
23044   fi
23045 
23046 
23047   if test "x$path" != "x$new_path"; then
23048     BOOT_JDK="$new_path"
23049     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23050 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23051   fi
23052 
23053     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23054 
23055   path="$BOOT_JDK"
23056   has_colon=`$ECHO $path | $GREP ^.:`
23057   new_path="$path"
23058   if test "x$has_colon" = x; then
23059     # Not in mixed or Windows style, start by that.
23060     new_path=`cmd //c echo $path`
23061   fi
23062 
23063 
23064   input_path="$new_path"
23065   # Check if we need to convert this using DOS-style short mode. If the path
23066   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23067   # take no chances and rewrite it.
23068   # Note: m4 eats our [], so we need to use [ and ] instead.
23069   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23070   if test "x$has_forbidden_chars" != x; then
23071     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23072     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23073   fi
23074 
23075 
23076   windows_path="$new_path"
23077   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23078     unix_path=`$CYGPATH -u "$windows_path"`
23079     new_path="$unix_path"
23080   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23081     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23082     new_path="$unix_path"
23083   fi
23084 
23085   if test "x$path" != "x$new_path"; then
23086     BOOT_JDK="$new_path"
23087     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23088 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23089   fi
23090 
23091   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23092   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23093 
23094     else
23095       # We're on a unix platform. Hooray! :)
23096       path="$BOOT_JDK"
23097       has_space=`$ECHO "$path" | $GREP " "`
23098       if test "x$has_space" != x; then
23099         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23100 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23101         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23102       fi
23103 
23104       # Use eval to expand a potential ~
23105       eval path="$path"
23106       if test ! -f "$path" && test ! -d "$path"; then
23107         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23108       fi
23109 
23110       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23111     fi
23112   fi
23113 
23114             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23115 $as_echo_n "checking for Boot JDK... " >&6; }
23116             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23117 $as_echo "$BOOT_JDK" >&6; }
23118             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23119 $as_echo_n "checking Boot JDK version... " >&6; }
23120             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23121             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23122 $as_echo "$BOOT_JDK_VERSION" >&6; }
23123           fi # end check jdk version
23124         fi # end check javac
23125       fi # end check java
23126     fi # end check boot jdk found
23127   fi
23128 
23129     done
23130   fi
23131 
23132   fi
23133 
23134 
23135     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23136     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23137       # Do we have a bin/java?
23138       if test ! -x "$BOOT_JDK/bin/java"; then
23139         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23140 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23141         BOOT_JDK_FOUND=no
23142       else
23143         # Do we have a bin/javac?
23144         if test ! -x "$BOOT_JDK/bin/javac"; then
23145           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23146 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23147           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23148 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23149           BOOT_JDK_FOUND=no
23150         else
23151           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23152           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23153 
23154           # Extra M4 quote needed to protect [] in grep expression.
23155           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23156           if test "x$FOUND_CORRECT_VERSION" = x; then
23157             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23158 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23159             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23160 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23161             BOOT_JDK_FOUND=no
23162           else
23163             # We're done! :-)
23164             BOOT_JDK_FOUND=yes
23165 
23166   # Only process if variable expands to non-empty
23167 
23168   if test "x$BOOT_JDK" != x; then
23169     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23170 
23171   # Input might be given as Windows format, start by converting to
23172   # unix format.
23173   path="$BOOT_JDK"
23174   new_path=`$CYGPATH -u "$path"`
23175 
23176   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23177   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23178   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23179   # "foo.exe" is OK but "foo" is an error.
23180   #
23181   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23182   # It is also a way to make sure we got the proper file name for the real test later on.
23183   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23184   if test "x$test_shortpath" = x; then
23185     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23186 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23187     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23188   fi
23189 
23190   # Call helper function which possibly converts this using DOS-style short mode.
23191   # If so, the updated path is stored in $new_path.
23192 
23193   input_path="$new_path"
23194   # Check if we need to convert this using DOS-style short mode. If the path
23195   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23196   # take no chances and rewrite it.
23197   # Note: m4 eats our [], so we need to use [ and ] instead.
23198   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23199   if test "x$has_forbidden_chars" != x; then
23200     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23201     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23202     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23203     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23204       # Going to short mode and back again did indeed matter. Since short mode is
23205       # case insensitive, let's make it lowercase to improve readability.
23206       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23207       # Now convert it back to Unix-stile (cygpath)
23208       input_path=`$CYGPATH -u "$shortmode_path"`
23209       new_path="$input_path"
23210     fi
23211   fi
23212 
23213   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23214   if test "x$test_cygdrive_prefix" = x; then
23215     # As a simple fix, exclude /usr/bin since it's not a real path.
23216     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23217       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23218       # a path prefixed by /cygdrive for fixpath to work.
23219       new_path="$CYGWIN_ROOT_PATH$input_path"
23220     fi
23221   fi
23222 
23223 
23224   if test "x$path" != "x$new_path"; then
23225     BOOT_JDK="$new_path"
23226     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23227 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23228   fi
23229 
23230     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23231 
23232   path="$BOOT_JDK"
23233   has_colon=`$ECHO $path | $GREP ^.:`
23234   new_path="$path"
23235   if test "x$has_colon" = x; then
23236     # Not in mixed or Windows style, start by that.
23237     new_path=`cmd //c echo $path`
23238   fi
23239 
23240 
23241   input_path="$new_path"
23242   # Check if we need to convert this using DOS-style short mode. If the path
23243   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23244   # take no chances and rewrite it.
23245   # Note: m4 eats our [], so we need to use [ and ] instead.
23246   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23247   if test "x$has_forbidden_chars" != x; then
23248     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23249     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23250   fi
23251 
23252 
23253   windows_path="$new_path"
23254   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23255     unix_path=`$CYGPATH -u "$windows_path"`
23256     new_path="$unix_path"
23257   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23258     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23259     new_path="$unix_path"
23260   fi
23261 
23262   if test "x$path" != "x$new_path"; then
23263     BOOT_JDK="$new_path"
23264     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23265 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23266   fi
23267 
23268   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23269   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23270 
23271     else
23272       # We're on a unix platform. Hooray! :)
23273       path="$BOOT_JDK"
23274       has_space=`$ECHO "$path" | $GREP " "`
23275       if test "x$has_space" != x; then
23276         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23277 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23278         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23279       fi
23280 
23281       # Use eval to expand a potential ~
23282       eval path="$path"
23283       if test ! -f "$path" && test ! -d "$path"; then
23284         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23285       fi
23286 
23287       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23288     fi
23289   fi
23290 
23291             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23292 $as_echo_n "checking for Boot JDK... " >&6; }
23293             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23294 $as_echo "$BOOT_JDK" >&6; }
23295             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23296 $as_echo_n "checking Boot JDK version... " >&6; }
23297             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23298             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23299 $as_echo "$BOOT_JDK_VERSION" >&6; }
23300           fi # end check jdk version
23301         fi # end check javac
23302       fi # end check java
23303     fi # end check boot jdk found
23304   fi
23305 
23306 
23307   if test "x$BOOT_JDK_FOUND" = xno; then
23308     # Now execute the test
23309 
23310   if test "x$ProgramFiles" != x; then
23311     VIRTUAL_DIR="$ProgramFiles/Java"
23312 
23313   windows_path="$VIRTUAL_DIR"
23314   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23315     unix_path=`$CYGPATH -u "$windows_path"`
23316     VIRTUAL_DIR="$unix_path"
23317   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23318     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23319     VIRTUAL_DIR="$unix_path"
23320   fi
23321 
23322 
23323   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
23324   BOOT_JDK_SUFFIX=""
23325   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23326   if test "x$ALL_JDKS_FOUND" != x; then
23327     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23328 
23329   if test "x$BOOT_JDK_FOUND" = xno; then
23330     # Now execute the test
23331 
23332         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23333         if test -d "$BOOT_JDK"; then
23334           BOOT_JDK_FOUND=maybe
23335           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23336 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23337         fi
23338 
23339 
23340     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23341     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23342       # Do we have a bin/java?
23343       if test ! -x "$BOOT_JDK/bin/java"; then
23344         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23345 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23346         BOOT_JDK_FOUND=no
23347       else
23348         # Do we have a bin/javac?
23349         if test ! -x "$BOOT_JDK/bin/javac"; then
23350           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23351 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23352           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23353 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23354           BOOT_JDK_FOUND=no
23355         else
23356           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23357           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23358 
23359           # Extra M4 quote needed to protect [] in grep expression.
23360           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23361           if test "x$FOUND_CORRECT_VERSION" = x; then
23362             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23363 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23364             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23365 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23366             BOOT_JDK_FOUND=no
23367           else
23368             # We're done! :-)
23369             BOOT_JDK_FOUND=yes
23370 
23371   # Only process if variable expands to non-empty
23372 
23373   if test "x$BOOT_JDK" != x; then
23374     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23375 
23376   # Input might be given as Windows format, start by converting to
23377   # unix format.
23378   path="$BOOT_JDK"
23379   new_path=`$CYGPATH -u "$path"`
23380 
23381   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23382   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23383   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23384   # "foo.exe" is OK but "foo" is an error.
23385   #
23386   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23387   # It is also a way to make sure we got the proper file name for the real test later on.
23388   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23389   if test "x$test_shortpath" = x; then
23390     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23391 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23392     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23393   fi
23394 
23395   # Call helper function which possibly converts this using DOS-style short mode.
23396   # If so, the updated path is stored in $new_path.
23397 
23398   input_path="$new_path"
23399   # Check if we need to convert this using DOS-style short mode. If the path
23400   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23401   # take no chances and rewrite it.
23402   # Note: m4 eats our [], so we need to use [ and ] instead.
23403   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23404   if test "x$has_forbidden_chars" != x; then
23405     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23406     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23407     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23408     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23409       # Going to short mode and back again did indeed matter. Since short mode is
23410       # case insensitive, let's make it lowercase to improve readability.
23411       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23412       # Now convert it back to Unix-stile (cygpath)
23413       input_path=`$CYGPATH -u "$shortmode_path"`
23414       new_path="$input_path"
23415     fi
23416   fi
23417 
23418   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23419   if test "x$test_cygdrive_prefix" = x; then
23420     # As a simple fix, exclude /usr/bin since it's not a real path.
23421     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23422       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23423       # a path prefixed by /cygdrive for fixpath to work.
23424       new_path="$CYGWIN_ROOT_PATH$input_path"
23425     fi
23426   fi
23427 
23428 
23429   if test "x$path" != "x$new_path"; then
23430     BOOT_JDK="$new_path"
23431     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23432 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23433   fi
23434 
23435     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23436 
23437   path="$BOOT_JDK"
23438   has_colon=`$ECHO $path | $GREP ^.:`
23439   new_path="$path"
23440   if test "x$has_colon" = x; then
23441     # Not in mixed or Windows style, start by that.
23442     new_path=`cmd //c echo $path`
23443   fi
23444 
23445 
23446   input_path="$new_path"
23447   # Check if we need to convert this using DOS-style short mode. If the path
23448   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23449   # take no chances and rewrite it.
23450   # Note: m4 eats our [], so we need to use [ and ] instead.
23451   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23452   if test "x$has_forbidden_chars" != x; then
23453     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23454     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23455   fi
23456 
23457 
23458   windows_path="$new_path"
23459   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23460     unix_path=`$CYGPATH -u "$windows_path"`
23461     new_path="$unix_path"
23462   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23463     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23464     new_path="$unix_path"
23465   fi
23466 
23467   if test "x$path" != "x$new_path"; then
23468     BOOT_JDK="$new_path"
23469     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23470 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23471   fi
23472 
23473   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23474   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23475 
23476     else
23477       # We're on a unix platform. Hooray! :)
23478       path="$BOOT_JDK"
23479       has_space=`$ECHO "$path" | $GREP " "`
23480       if test "x$has_space" != x; then
23481         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23482 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23483         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23484       fi
23485 
23486       # Use eval to expand a potential ~
23487       eval path="$path"
23488       if test ! -f "$path" && test ! -d "$path"; then
23489         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23490       fi
23491 
23492       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23493     fi
23494   fi
23495 
23496             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23497 $as_echo_n "checking for Boot JDK... " >&6; }
23498             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23499 $as_echo "$BOOT_JDK" >&6; }
23500             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23501 $as_echo_n "checking Boot JDK version... " >&6; }
23502             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23503             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23504 $as_echo "$BOOT_JDK_VERSION" >&6; }
23505           fi # end check jdk version
23506         fi # end check javac
23507       fi # end check java
23508     fi # end check boot jdk found
23509   fi
23510 
23511     done
23512   fi
23513 
23514   fi
23515 
23516 
23517     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23518     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23519       # Do we have a bin/java?
23520       if test ! -x "$BOOT_JDK/bin/java"; then
23521         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23522 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23523         BOOT_JDK_FOUND=no
23524       else
23525         # Do we have a bin/javac?
23526         if test ! -x "$BOOT_JDK/bin/javac"; then
23527           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23528 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23529           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23530 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23531           BOOT_JDK_FOUND=no
23532         else
23533           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23534           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23535 
23536           # Extra M4 quote needed to protect [] in grep expression.
23537           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23538           if test "x$FOUND_CORRECT_VERSION" = x; then
23539             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23540 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23541             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23542 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23543             BOOT_JDK_FOUND=no
23544           else
23545             # We're done! :-)
23546             BOOT_JDK_FOUND=yes
23547 
23548   # Only process if variable expands to non-empty
23549 
23550   if test "x$BOOT_JDK" != x; then
23551     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23552 
23553   # Input might be given as Windows format, start by converting to
23554   # unix format.
23555   path="$BOOT_JDK"
23556   new_path=`$CYGPATH -u "$path"`
23557 
23558   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23559   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23560   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23561   # "foo.exe" is OK but "foo" is an error.
23562   #
23563   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23564   # It is also a way to make sure we got the proper file name for the real test later on.
23565   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23566   if test "x$test_shortpath" = x; then
23567     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23568 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23569     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23570   fi
23571 
23572   # Call helper function which possibly converts this using DOS-style short mode.
23573   # If so, the updated path is stored in $new_path.
23574 
23575   input_path="$new_path"
23576   # Check if we need to convert this using DOS-style short mode. If the path
23577   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23578   # take no chances and rewrite it.
23579   # Note: m4 eats our [], so we need to use [ and ] instead.
23580   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23581   if test "x$has_forbidden_chars" != x; then
23582     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23583     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23584     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23585     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23586       # Going to short mode and back again did indeed matter. Since short mode is
23587       # case insensitive, let's make it lowercase to improve readability.
23588       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23589       # Now convert it back to Unix-stile (cygpath)
23590       input_path=`$CYGPATH -u "$shortmode_path"`
23591       new_path="$input_path"
23592     fi
23593   fi
23594 
23595   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23596   if test "x$test_cygdrive_prefix" = x; then
23597     # As a simple fix, exclude /usr/bin since it's not a real path.
23598     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23599       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23600       # a path prefixed by /cygdrive for fixpath to work.
23601       new_path="$CYGWIN_ROOT_PATH$input_path"
23602     fi
23603   fi
23604 
23605 
23606   if test "x$path" != "x$new_path"; then
23607     BOOT_JDK="$new_path"
23608     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23609 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23610   fi
23611 
23612     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23613 
23614   path="$BOOT_JDK"
23615   has_colon=`$ECHO $path | $GREP ^.:`
23616   new_path="$path"
23617   if test "x$has_colon" = x; then
23618     # Not in mixed or Windows style, start by that.
23619     new_path=`cmd //c echo $path`
23620   fi
23621 
23622 
23623   input_path="$new_path"
23624   # Check if we need to convert this using DOS-style short mode. If the path
23625   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23626   # take no chances and rewrite it.
23627   # Note: m4 eats our [], so we need to use [ and ] instead.
23628   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23629   if test "x$has_forbidden_chars" != x; then
23630     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23631     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23632   fi
23633 
23634 
23635   windows_path="$new_path"
23636   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23637     unix_path=`$CYGPATH -u "$windows_path"`
23638     new_path="$unix_path"
23639   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23640     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23641     new_path="$unix_path"
23642   fi
23643 
23644   if test "x$path" != "x$new_path"; then
23645     BOOT_JDK="$new_path"
23646     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23647 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23648   fi
23649 
23650   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23651   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23652 
23653     else
23654       # We're on a unix platform. Hooray! :)
23655       path="$BOOT_JDK"
23656       has_space=`$ECHO "$path" | $GREP " "`
23657       if test "x$has_space" != x; then
23658         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23659 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23660         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23661       fi
23662 
23663       # Use eval to expand a potential ~
23664       eval path="$path"
23665       if test ! -f "$path" && test ! -d "$path"; then
23666         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23667       fi
23668 
23669       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23670     fi
23671   fi
23672 
23673             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23674 $as_echo_n "checking for Boot JDK... " >&6; }
23675             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23676 $as_echo "$BOOT_JDK" >&6; }
23677             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23678 $as_echo_n "checking Boot JDK version... " >&6; }
23679             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23680             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23681 $as_echo "$BOOT_JDK_VERSION" >&6; }
23682           fi # end check jdk version
23683         fi # end check javac
23684       fi # end check java
23685     fi # end check boot jdk found
23686   fi
23687 
23688 
23689   if test "x$BOOT_JDK_FOUND" = xno; then
23690     # Now execute the test
23691 
23692   BOOT_JDK_PREFIX="/cygdrive/c/Program Files/Java"
23693   BOOT_JDK_SUFFIX=""
23694   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23695   if test "x$ALL_JDKS_FOUND" != x; then
23696     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23697 
23698   if test "x$BOOT_JDK_FOUND" = xno; then
23699     # Now execute the test
23700 
23701         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23702         if test -d "$BOOT_JDK"; then
23703           BOOT_JDK_FOUND=maybe
23704           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23705 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23706         fi
23707 
23708 
23709     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23710     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23711       # Do we have a bin/java?
23712       if test ! -x "$BOOT_JDK/bin/java"; then
23713         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23714 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23715         BOOT_JDK_FOUND=no
23716       else
23717         # Do we have a bin/javac?
23718         if test ! -x "$BOOT_JDK/bin/javac"; then
23719           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23720 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23721           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23722 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23723           BOOT_JDK_FOUND=no
23724         else
23725           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23726           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23727 
23728           # Extra M4 quote needed to protect [] in grep expression.
23729           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23730           if test "x$FOUND_CORRECT_VERSION" = x; then
23731             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23732 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23733             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23734 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23735             BOOT_JDK_FOUND=no
23736           else
23737             # We're done! :-)
23738             BOOT_JDK_FOUND=yes
23739 
23740   # Only process if variable expands to non-empty
23741 
23742   if test "x$BOOT_JDK" != x; then
23743     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23744 
23745   # Input might be given as Windows format, start by converting to
23746   # unix format.
23747   path="$BOOT_JDK"
23748   new_path=`$CYGPATH -u "$path"`
23749 
23750   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23751   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23752   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23753   # "foo.exe" is OK but "foo" is an error.
23754   #
23755   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23756   # It is also a way to make sure we got the proper file name for the real test later on.
23757   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23758   if test "x$test_shortpath" = x; then
23759     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23760 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23761     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23762   fi
23763 
23764   # Call helper function which possibly converts this using DOS-style short mode.
23765   # If so, the updated path is stored in $new_path.
23766 
23767   input_path="$new_path"
23768   # Check if we need to convert this using DOS-style short mode. If the path
23769   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23770   # take no chances and rewrite it.
23771   # Note: m4 eats our [], so we need to use [ and ] instead.
23772   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23773   if test "x$has_forbidden_chars" != x; then
23774     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23775     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23776     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23777     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23778       # Going to short mode and back again did indeed matter. Since short mode is
23779       # case insensitive, let's make it lowercase to improve readability.
23780       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23781       # Now convert it back to Unix-stile (cygpath)
23782       input_path=`$CYGPATH -u "$shortmode_path"`
23783       new_path="$input_path"
23784     fi
23785   fi
23786 
23787   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23788   if test "x$test_cygdrive_prefix" = x; then
23789     # As a simple fix, exclude /usr/bin since it's not a real path.
23790     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23791       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23792       # a path prefixed by /cygdrive for fixpath to work.
23793       new_path="$CYGWIN_ROOT_PATH$input_path"
23794     fi
23795   fi
23796 
23797 
23798   if test "x$path" != "x$new_path"; then
23799     BOOT_JDK="$new_path"
23800     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23801 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23802   fi
23803 
23804     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23805 
23806   path="$BOOT_JDK"
23807   has_colon=`$ECHO $path | $GREP ^.:`
23808   new_path="$path"
23809   if test "x$has_colon" = x; then
23810     # Not in mixed or Windows style, start by that.
23811     new_path=`cmd //c echo $path`
23812   fi
23813 
23814 
23815   input_path="$new_path"
23816   # Check if we need to convert this using DOS-style short mode. If the path
23817   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23818   # take no chances and rewrite it.
23819   # Note: m4 eats our [], so we need to use [ and ] instead.
23820   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23821   if test "x$has_forbidden_chars" != x; then
23822     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23823     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23824   fi
23825 
23826 
23827   windows_path="$new_path"
23828   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23829     unix_path=`$CYGPATH -u "$windows_path"`
23830     new_path="$unix_path"
23831   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23832     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23833     new_path="$unix_path"
23834   fi
23835 
23836   if test "x$path" != "x$new_path"; then
23837     BOOT_JDK="$new_path"
23838     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23839 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23840   fi
23841 
23842   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23843   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23844 
23845     else
23846       # We're on a unix platform. Hooray! :)
23847       path="$BOOT_JDK"
23848       has_space=`$ECHO "$path" | $GREP " "`
23849       if test "x$has_space" != x; then
23850         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23851 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23852         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23853       fi
23854 
23855       # Use eval to expand a potential ~
23856       eval path="$path"
23857       if test ! -f "$path" && test ! -d "$path"; then
23858         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23859       fi
23860 
23861       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23862     fi
23863   fi
23864 
23865             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23866 $as_echo_n "checking for Boot JDK... " >&6; }
23867             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23868 $as_echo "$BOOT_JDK" >&6; }
23869             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23870 $as_echo_n "checking Boot JDK version... " >&6; }
23871             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23872             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23873 $as_echo "$BOOT_JDK_VERSION" >&6; }
23874           fi # end check jdk version
23875         fi # end check javac
23876       fi # end check java
23877     fi # end check boot jdk found
23878   fi
23879 
23880     done
23881   fi
23882 
23883 
23884     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23885     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23886       # Do we have a bin/java?
23887       if test ! -x "$BOOT_JDK/bin/java"; then
23888         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23889 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23890         BOOT_JDK_FOUND=no
23891       else
23892         # Do we have a bin/javac?
23893         if test ! -x "$BOOT_JDK/bin/javac"; then
23894           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23895 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23896           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23897 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23898           BOOT_JDK_FOUND=no
23899         else
23900           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23901           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23902 
23903           # Extra M4 quote needed to protect [] in grep expression.
23904           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23905           if test "x$FOUND_CORRECT_VERSION" = x; then
23906             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23907 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23908             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23909 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23910             BOOT_JDK_FOUND=no
23911           else
23912             # We're done! :-)
23913             BOOT_JDK_FOUND=yes
23914 
23915   # Only process if variable expands to non-empty
23916 
23917   if test "x$BOOT_JDK" != x; then
23918     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23919 
23920   # Input might be given as Windows format, start by converting to
23921   # unix format.
23922   path="$BOOT_JDK"
23923   new_path=`$CYGPATH -u "$path"`
23924 
23925   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23926   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23927   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23928   # "foo.exe" is OK but "foo" is an error.
23929   #
23930   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23931   # It is also a way to make sure we got the proper file name for the real test later on.
23932   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23933   if test "x$test_shortpath" = x; then
23934     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23935 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23936     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23937   fi
23938 
23939   # Call helper function which possibly converts this using DOS-style short mode.
23940   # If so, the updated path is stored in $new_path.
23941 
23942   input_path="$new_path"
23943   # Check if we need to convert this using DOS-style short mode. If the path
23944   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23945   # take no chances and rewrite it.
23946   # Note: m4 eats our [], so we need to use [ and ] instead.
23947   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23948   if test "x$has_forbidden_chars" != x; then
23949     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23950     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23951     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23952     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23953       # Going to short mode and back again did indeed matter. Since short mode is
23954       # case insensitive, let's make it lowercase to improve readability.
23955       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23956       # Now convert it back to Unix-stile (cygpath)
23957       input_path=`$CYGPATH -u "$shortmode_path"`
23958       new_path="$input_path"
23959     fi
23960   fi
23961 
23962   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23963   if test "x$test_cygdrive_prefix" = x; then
23964     # As a simple fix, exclude /usr/bin since it's not a real path.
23965     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23966       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23967       # a path prefixed by /cygdrive for fixpath to work.
23968       new_path="$CYGWIN_ROOT_PATH$input_path"
23969     fi
23970   fi
23971 
23972 
23973   if test "x$path" != "x$new_path"; then
23974     BOOT_JDK="$new_path"
23975     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23976 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23977   fi
23978 
23979     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23980 
23981   path="$BOOT_JDK"
23982   has_colon=`$ECHO $path | $GREP ^.:`
23983   new_path="$path"
23984   if test "x$has_colon" = x; then
23985     # Not in mixed or Windows style, start by that.
23986     new_path=`cmd //c echo $path`
23987   fi
23988 
23989 
23990   input_path="$new_path"
23991   # Check if we need to convert this using DOS-style short mode. If the path
23992   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23993   # take no chances and rewrite it.
23994   # Note: m4 eats our [], so we need to use [ and ] instead.
23995   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23996   if test "x$has_forbidden_chars" != x; then
23997     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23998     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23999   fi
24000 
24001 
24002   windows_path="$new_path"
24003   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24004     unix_path=`$CYGPATH -u "$windows_path"`
24005     new_path="$unix_path"
24006   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24007     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24008     new_path="$unix_path"
24009   fi
24010 
24011   if test "x$path" != "x$new_path"; then
24012     BOOT_JDK="$new_path"
24013     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24014 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24015   fi
24016 
24017   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24018   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24019 
24020     else
24021       # We're on a unix platform. Hooray! :)
24022       path="$BOOT_JDK"
24023       has_space=`$ECHO "$path" | $GREP " "`
24024       if test "x$has_space" != x; then
24025         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24026 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24027         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24028       fi
24029 
24030       # Use eval to expand a potential ~
24031       eval path="$path"
24032       if test ! -f "$path" && test ! -d "$path"; then
24033         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24034       fi
24035 
24036       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24037     fi
24038   fi
24039 
24040             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24041 $as_echo_n "checking for Boot JDK... " >&6; }
24042             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24043 $as_echo "$BOOT_JDK" >&6; }
24044             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24045 $as_echo_n "checking Boot JDK version... " >&6; }
24046             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24047             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24048 $as_echo "$BOOT_JDK_VERSION" >&6; }
24049           fi # end check jdk version
24050         fi # end check javac
24051       fi # end check java
24052     fi # end check boot jdk found
24053   fi
24054 
24055   elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
24056 
24057   if test "x$BOOT_JDK_FOUND" = xno; then
24058     # Now execute the test
24059 
24060   BOOT_JDK_PREFIX="/Library/Java/JavaVirtualMachines"
24061   BOOT_JDK_SUFFIX="/Contents/Home"
24062   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24063   if test "x$ALL_JDKS_FOUND" != x; then
24064     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24065 
24066   if test "x$BOOT_JDK_FOUND" = xno; then
24067     # Now execute the test
24068 
24069         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24070         if test -d "$BOOT_JDK"; then
24071           BOOT_JDK_FOUND=maybe
24072           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24073 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24074         fi
24075 
24076 
24077     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24078     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24079       # Do we have a bin/java?
24080       if test ! -x "$BOOT_JDK/bin/java"; then
24081         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24082 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24083         BOOT_JDK_FOUND=no
24084       else
24085         # Do we have a bin/javac?
24086         if test ! -x "$BOOT_JDK/bin/javac"; then
24087           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24088 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24089           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24090 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24091           BOOT_JDK_FOUND=no
24092         else
24093           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24094           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24095 
24096           # Extra M4 quote needed to protect [] in grep expression.
24097           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24098           if test "x$FOUND_CORRECT_VERSION" = x; then
24099             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24100 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24101             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24102 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24103             BOOT_JDK_FOUND=no
24104           else
24105             # We're done! :-)
24106             BOOT_JDK_FOUND=yes
24107 
24108   # Only process if variable expands to non-empty
24109 
24110   if test "x$BOOT_JDK" != x; then
24111     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24112 
24113   # Input might be given as Windows format, start by converting to
24114   # unix format.
24115   path="$BOOT_JDK"
24116   new_path=`$CYGPATH -u "$path"`
24117 
24118   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24119   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24120   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24121   # "foo.exe" is OK but "foo" is an error.
24122   #
24123   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24124   # It is also a way to make sure we got the proper file name for the real test later on.
24125   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24126   if test "x$test_shortpath" = x; then
24127     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24128 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24129     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24130   fi
24131 
24132   # Call helper function which possibly converts this using DOS-style short mode.
24133   # If so, the updated path is stored in $new_path.
24134 
24135   input_path="$new_path"
24136   # Check if we need to convert this using DOS-style short mode. If the path
24137   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24138   # take no chances and rewrite it.
24139   # Note: m4 eats our [], so we need to use [ and ] instead.
24140   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24141   if test "x$has_forbidden_chars" != x; then
24142     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24143     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24144     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24145     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24146       # Going to short mode and back again did indeed matter. Since short mode is
24147       # case insensitive, let's make it lowercase to improve readability.
24148       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24149       # Now convert it back to Unix-stile (cygpath)
24150       input_path=`$CYGPATH -u "$shortmode_path"`
24151       new_path="$input_path"
24152     fi
24153   fi
24154 
24155   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24156   if test "x$test_cygdrive_prefix" = x; then
24157     # As a simple fix, exclude /usr/bin since it's not a real path.
24158     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24159       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24160       # a path prefixed by /cygdrive for fixpath to work.
24161       new_path="$CYGWIN_ROOT_PATH$input_path"
24162     fi
24163   fi
24164 
24165 
24166   if test "x$path" != "x$new_path"; then
24167     BOOT_JDK="$new_path"
24168     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24169 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24170   fi
24171 
24172     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24173 
24174   path="$BOOT_JDK"
24175   has_colon=`$ECHO $path | $GREP ^.:`
24176   new_path="$path"
24177   if test "x$has_colon" = x; then
24178     # Not in mixed or Windows style, start by that.
24179     new_path=`cmd //c echo $path`
24180   fi
24181 
24182 
24183   input_path="$new_path"
24184   # Check if we need to convert this using DOS-style short mode. If the path
24185   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24186   # take no chances and rewrite it.
24187   # Note: m4 eats our [], so we need to use [ and ] instead.
24188   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24189   if test "x$has_forbidden_chars" != x; then
24190     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24191     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24192   fi
24193 
24194 
24195   windows_path="$new_path"
24196   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24197     unix_path=`$CYGPATH -u "$windows_path"`
24198     new_path="$unix_path"
24199   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24200     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24201     new_path="$unix_path"
24202   fi
24203 
24204   if test "x$path" != "x$new_path"; then
24205     BOOT_JDK="$new_path"
24206     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24207 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24208   fi
24209 
24210   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24211   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24212 
24213     else
24214       # We're on a unix platform. Hooray! :)
24215       path="$BOOT_JDK"
24216       has_space=`$ECHO "$path" | $GREP " "`
24217       if test "x$has_space" != x; then
24218         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24219 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24220         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24221       fi
24222 
24223       # Use eval to expand a potential ~
24224       eval path="$path"
24225       if test ! -f "$path" && test ! -d "$path"; then
24226         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24227       fi
24228 
24229       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24230     fi
24231   fi
24232 
24233             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24234 $as_echo_n "checking for Boot JDK... " >&6; }
24235             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24236 $as_echo "$BOOT_JDK" >&6; }
24237             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24238 $as_echo_n "checking Boot JDK version... " >&6; }
24239             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24240             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24241 $as_echo "$BOOT_JDK_VERSION" >&6; }
24242           fi # end check jdk version
24243         fi # end check javac
24244       fi # end check java
24245     fi # end check boot jdk found
24246   fi
24247 
24248     done
24249   fi
24250 
24251 
24252     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24253     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24254       # Do we have a bin/java?
24255       if test ! -x "$BOOT_JDK/bin/java"; then
24256         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24257 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24258         BOOT_JDK_FOUND=no
24259       else
24260         # Do we have a bin/javac?
24261         if test ! -x "$BOOT_JDK/bin/javac"; then
24262           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24263 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24264           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24265 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24266           BOOT_JDK_FOUND=no
24267         else
24268           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24269           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24270 
24271           # Extra M4 quote needed to protect [] in grep expression.
24272           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24273           if test "x$FOUND_CORRECT_VERSION" = x; then
24274             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24275 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24276             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24277 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24278             BOOT_JDK_FOUND=no
24279           else
24280             # We're done! :-)
24281             BOOT_JDK_FOUND=yes
24282 
24283   # Only process if variable expands to non-empty
24284 
24285   if test "x$BOOT_JDK" != x; then
24286     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24287 
24288   # Input might be given as Windows format, start by converting to
24289   # unix format.
24290   path="$BOOT_JDK"
24291   new_path=`$CYGPATH -u "$path"`
24292 
24293   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24294   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24295   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24296   # "foo.exe" is OK but "foo" is an error.
24297   #
24298   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24299   # It is also a way to make sure we got the proper file name for the real test later on.
24300   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24301   if test "x$test_shortpath" = x; then
24302     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24303 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24304     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24305   fi
24306 
24307   # Call helper function which possibly converts this using DOS-style short mode.
24308   # If so, the updated path is stored in $new_path.
24309 
24310   input_path="$new_path"
24311   # Check if we need to convert this using DOS-style short mode. If the path
24312   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24313   # take no chances and rewrite it.
24314   # Note: m4 eats our [], so we need to use [ and ] instead.
24315   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24316   if test "x$has_forbidden_chars" != x; then
24317     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24318     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24319     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24320     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24321       # Going to short mode and back again did indeed matter. Since short mode is
24322       # case insensitive, let's make it lowercase to improve readability.
24323       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24324       # Now convert it back to Unix-stile (cygpath)
24325       input_path=`$CYGPATH -u "$shortmode_path"`
24326       new_path="$input_path"
24327     fi
24328   fi
24329 
24330   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24331   if test "x$test_cygdrive_prefix" = x; then
24332     # As a simple fix, exclude /usr/bin since it's not a real path.
24333     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24334       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24335       # a path prefixed by /cygdrive for fixpath to work.
24336       new_path="$CYGWIN_ROOT_PATH$input_path"
24337     fi
24338   fi
24339 
24340 
24341   if test "x$path" != "x$new_path"; then
24342     BOOT_JDK="$new_path"
24343     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24344 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24345   fi
24346 
24347     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24348 
24349   path="$BOOT_JDK"
24350   has_colon=`$ECHO $path | $GREP ^.:`
24351   new_path="$path"
24352   if test "x$has_colon" = x; then
24353     # Not in mixed or Windows style, start by that.
24354     new_path=`cmd //c echo $path`
24355   fi
24356 
24357 
24358   input_path="$new_path"
24359   # Check if we need to convert this using DOS-style short mode. If the path
24360   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24361   # take no chances and rewrite it.
24362   # Note: m4 eats our [], so we need to use [ and ] instead.
24363   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24364   if test "x$has_forbidden_chars" != x; then
24365     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24366     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24367   fi
24368 
24369 
24370   windows_path="$new_path"
24371   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24372     unix_path=`$CYGPATH -u "$windows_path"`
24373     new_path="$unix_path"
24374   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24375     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24376     new_path="$unix_path"
24377   fi
24378 
24379   if test "x$path" != "x$new_path"; then
24380     BOOT_JDK="$new_path"
24381     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24382 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24383   fi
24384 
24385   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24386   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24387 
24388     else
24389       # We're on a unix platform. Hooray! :)
24390       path="$BOOT_JDK"
24391       has_space=`$ECHO "$path" | $GREP " "`
24392       if test "x$has_space" != x; then
24393         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24394 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24395         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24396       fi
24397 
24398       # Use eval to expand a potential ~
24399       eval path="$path"
24400       if test ! -f "$path" && test ! -d "$path"; then
24401         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24402       fi
24403 
24404       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24405     fi
24406   fi
24407 
24408             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24409 $as_echo_n "checking for Boot JDK... " >&6; }
24410             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24411 $as_echo "$BOOT_JDK" >&6; }
24412             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24413 $as_echo_n "checking Boot JDK version... " >&6; }
24414             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24415             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24416 $as_echo "$BOOT_JDK_VERSION" >&6; }
24417           fi # end check jdk version
24418         fi # end check javac
24419       fi # end check java
24420     fi # end check boot jdk found
24421   fi
24422 
24423 
24424   if test "x$BOOT_JDK_FOUND" = xno; then
24425     # Now execute the test
24426 
24427   BOOT_JDK_PREFIX="/System/Library/Java/JavaVirtualMachines"
24428   BOOT_JDK_SUFFIX="/Contents/Home"
24429   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24430   if test "x$ALL_JDKS_FOUND" != x; then
24431     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24432 
24433   if test "x$BOOT_JDK_FOUND" = xno; then
24434     # Now execute the test
24435 
24436         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24437         if test -d "$BOOT_JDK"; then
24438           BOOT_JDK_FOUND=maybe
24439           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24440 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24441         fi
24442 
24443 
24444     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24445     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24446       # Do we have a bin/java?
24447       if test ! -x "$BOOT_JDK/bin/java"; then
24448         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24449 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24450         BOOT_JDK_FOUND=no
24451       else
24452         # Do we have a bin/javac?
24453         if test ! -x "$BOOT_JDK/bin/javac"; then
24454           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24455 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24456           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24457 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24458           BOOT_JDK_FOUND=no
24459         else
24460           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24461           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24462 
24463           # Extra M4 quote needed to protect [] in grep expression.
24464           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24465           if test "x$FOUND_CORRECT_VERSION" = x; then
24466             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24467 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24468             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24469 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24470             BOOT_JDK_FOUND=no
24471           else
24472             # We're done! :-)
24473             BOOT_JDK_FOUND=yes
24474 
24475   # Only process if variable expands to non-empty
24476 
24477   if test "x$BOOT_JDK" != x; then
24478     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24479 
24480   # Input might be given as Windows format, start by converting to
24481   # unix format.
24482   path="$BOOT_JDK"
24483   new_path=`$CYGPATH -u "$path"`
24484 
24485   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24486   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24487   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24488   # "foo.exe" is OK but "foo" is an error.
24489   #
24490   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24491   # It is also a way to make sure we got the proper file name for the real test later on.
24492   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24493   if test "x$test_shortpath" = x; then
24494     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24495 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24496     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24497   fi
24498 
24499   # Call helper function which possibly converts this using DOS-style short mode.
24500   # If so, the updated path is stored in $new_path.
24501 
24502   input_path="$new_path"
24503   # Check if we need to convert this using DOS-style short mode. If the path
24504   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24505   # take no chances and rewrite it.
24506   # Note: m4 eats our [], so we need to use [ and ] instead.
24507   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24508   if test "x$has_forbidden_chars" != x; then
24509     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24510     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24511     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24512     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24513       # Going to short mode and back again did indeed matter. Since short mode is
24514       # case insensitive, let's make it lowercase to improve readability.
24515       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24516       # Now convert it back to Unix-stile (cygpath)
24517       input_path=`$CYGPATH -u "$shortmode_path"`
24518       new_path="$input_path"
24519     fi
24520   fi
24521 
24522   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24523   if test "x$test_cygdrive_prefix" = x; then
24524     # As a simple fix, exclude /usr/bin since it's not a real path.
24525     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24526       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24527       # a path prefixed by /cygdrive for fixpath to work.
24528       new_path="$CYGWIN_ROOT_PATH$input_path"
24529     fi
24530   fi
24531 
24532 
24533   if test "x$path" != "x$new_path"; then
24534     BOOT_JDK="$new_path"
24535     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24536 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24537   fi
24538 
24539     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24540 
24541   path="$BOOT_JDK"
24542   has_colon=`$ECHO $path | $GREP ^.:`
24543   new_path="$path"
24544   if test "x$has_colon" = x; then
24545     # Not in mixed or Windows style, start by that.
24546     new_path=`cmd //c echo $path`
24547   fi
24548 
24549 
24550   input_path="$new_path"
24551   # Check if we need to convert this using DOS-style short mode. If the path
24552   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24553   # take no chances and rewrite it.
24554   # Note: m4 eats our [], so we need to use [ and ] instead.
24555   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24556   if test "x$has_forbidden_chars" != x; then
24557     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24558     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24559   fi
24560 
24561 
24562   windows_path="$new_path"
24563   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24564     unix_path=`$CYGPATH -u "$windows_path"`
24565     new_path="$unix_path"
24566   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24567     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24568     new_path="$unix_path"
24569   fi
24570 
24571   if test "x$path" != "x$new_path"; then
24572     BOOT_JDK="$new_path"
24573     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24574 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24575   fi
24576 
24577   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24578   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24579 
24580     else
24581       # We're on a unix platform. Hooray! :)
24582       path="$BOOT_JDK"
24583       has_space=`$ECHO "$path" | $GREP " "`
24584       if test "x$has_space" != x; then
24585         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24586 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24587         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24588       fi
24589 
24590       # Use eval to expand a potential ~
24591       eval path="$path"
24592       if test ! -f "$path" && test ! -d "$path"; then
24593         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24594       fi
24595 
24596       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24597     fi
24598   fi
24599 
24600             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24601 $as_echo_n "checking for Boot JDK... " >&6; }
24602             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24603 $as_echo "$BOOT_JDK" >&6; }
24604             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24605 $as_echo_n "checking Boot JDK version... " >&6; }
24606             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24607             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24608 $as_echo "$BOOT_JDK_VERSION" >&6; }
24609           fi # end check jdk version
24610         fi # end check javac
24611       fi # end check java
24612     fi # end check boot jdk found
24613   fi
24614 
24615     done
24616   fi
24617 
24618 
24619     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24620     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24621       # Do we have a bin/java?
24622       if test ! -x "$BOOT_JDK/bin/java"; then
24623         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24624 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24625         BOOT_JDK_FOUND=no
24626       else
24627         # Do we have a bin/javac?
24628         if test ! -x "$BOOT_JDK/bin/javac"; then
24629           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24630 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24631           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24632 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24633           BOOT_JDK_FOUND=no
24634         else
24635           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24636           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24637 
24638           # Extra M4 quote needed to protect [] in grep expression.
24639           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24640           if test "x$FOUND_CORRECT_VERSION" = x; then
24641             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24642 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24643             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24644 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24645             BOOT_JDK_FOUND=no
24646           else
24647             # We're done! :-)
24648             BOOT_JDK_FOUND=yes
24649 
24650   # Only process if variable expands to non-empty
24651 
24652   if test "x$BOOT_JDK" != x; then
24653     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24654 
24655   # Input might be given as Windows format, start by converting to
24656   # unix format.
24657   path="$BOOT_JDK"
24658   new_path=`$CYGPATH -u "$path"`
24659 
24660   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24661   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24662   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24663   # "foo.exe" is OK but "foo" is an error.
24664   #
24665   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24666   # It is also a way to make sure we got the proper file name for the real test later on.
24667   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24668   if test "x$test_shortpath" = x; then
24669     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24670 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24671     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24672   fi
24673 
24674   # Call helper function which possibly converts this using DOS-style short mode.
24675   # If so, the updated path is stored in $new_path.
24676 
24677   input_path="$new_path"
24678   # Check if we need to convert this using DOS-style short mode. If the path
24679   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24680   # take no chances and rewrite it.
24681   # Note: m4 eats our [], so we need to use [ and ] instead.
24682   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24683   if test "x$has_forbidden_chars" != x; then
24684     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24685     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24686     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24687     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24688       # Going to short mode and back again did indeed matter. Since short mode is
24689       # case insensitive, let's make it lowercase to improve readability.
24690       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24691       # Now convert it back to Unix-stile (cygpath)
24692       input_path=`$CYGPATH -u "$shortmode_path"`
24693       new_path="$input_path"
24694     fi
24695   fi
24696 
24697   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24698   if test "x$test_cygdrive_prefix" = x; then
24699     # As a simple fix, exclude /usr/bin since it's not a real path.
24700     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24701       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24702       # a path prefixed by /cygdrive for fixpath to work.
24703       new_path="$CYGWIN_ROOT_PATH$input_path"
24704     fi
24705   fi
24706 
24707 
24708   if test "x$path" != "x$new_path"; then
24709     BOOT_JDK="$new_path"
24710     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24711 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24712   fi
24713 
24714     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24715 
24716   path="$BOOT_JDK"
24717   has_colon=`$ECHO $path | $GREP ^.:`
24718   new_path="$path"
24719   if test "x$has_colon" = x; then
24720     # Not in mixed or Windows style, start by that.
24721     new_path=`cmd //c echo $path`
24722   fi
24723 
24724 
24725   input_path="$new_path"
24726   # Check if we need to convert this using DOS-style short mode. If the path
24727   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24728   # take no chances and rewrite it.
24729   # Note: m4 eats our [], so we need to use [ and ] instead.
24730   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24731   if test "x$has_forbidden_chars" != x; then
24732     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24733     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24734   fi
24735 
24736 
24737   windows_path="$new_path"
24738   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24739     unix_path=`$CYGPATH -u "$windows_path"`
24740     new_path="$unix_path"
24741   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24742     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24743     new_path="$unix_path"
24744   fi
24745 
24746   if test "x$path" != "x$new_path"; then
24747     BOOT_JDK="$new_path"
24748     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24749 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24750   fi
24751 
24752   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24753   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24754 
24755     else
24756       # We're on a unix platform. Hooray! :)
24757       path="$BOOT_JDK"
24758       has_space=`$ECHO "$path" | $GREP " "`
24759       if test "x$has_space" != x; then
24760         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24761 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24762         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24763       fi
24764 
24765       # Use eval to expand a potential ~
24766       eval path="$path"
24767       if test ! -f "$path" && test ! -d "$path"; then
24768         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24769       fi
24770 
24771       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24772     fi
24773   fi
24774 
24775             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24776 $as_echo_n "checking for Boot JDK... " >&6; }
24777             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24778 $as_echo "$BOOT_JDK" >&6; }
24779             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24780 $as_echo_n "checking Boot JDK version... " >&6; }
24781             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24782             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24783 $as_echo "$BOOT_JDK_VERSION" >&6; }
24784           fi # end check jdk version
24785         fi # end check javac
24786       fi # end check java
24787     fi # end check boot jdk found
24788   fi
24789 
24790   elif test "x$OPENJDK_TARGET_OS" = xlinux; then
24791 
24792   if test "x$BOOT_JDK_FOUND" = xno; then
24793     # Now execute the test
24794 
24795   BOOT_JDK_PREFIX="/usr/lib/jvm"
24796   BOOT_JDK_SUFFIX=""
24797   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24798   if test "x$ALL_JDKS_FOUND" != x; then
24799     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24800 
24801   if test "x$BOOT_JDK_FOUND" = xno; then
24802     # Now execute the test
24803 
24804         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24805         if test -d "$BOOT_JDK"; then
24806           BOOT_JDK_FOUND=maybe
24807           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24808 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24809         fi
24810 
24811 
24812     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24813     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24814       # Do we have a bin/java?
24815       if test ! -x "$BOOT_JDK/bin/java"; then
24816         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24817 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24818         BOOT_JDK_FOUND=no
24819       else
24820         # Do we have a bin/javac?
24821         if test ! -x "$BOOT_JDK/bin/javac"; then
24822           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24823 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24824           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24825 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24826           BOOT_JDK_FOUND=no
24827         else
24828           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24829           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24830 
24831           # Extra M4 quote needed to protect [] in grep expression.
24832           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24833           if test "x$FOUND_CORRECT_VERSION" = x; then
24834             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24835 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24836             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24837 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24838             BOOT_JDK_FOUND=no
24839           else
24840             # We're done! :-)
24841             BOOT_JDK_FOUND=yes
24842 
24843   # Only process if variable expands to non-empty
24844 
24845   if test "x$BOOT_JDK" != x; then
24846     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24847 
24848   # Input might be given as Windows format, start by converting to
24849   # unix format.
24850   path="$BOOT_JDK"
24851   new_path=`$CYGPATH -u "$path"`
24852 
24853   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24854   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24855   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24856   # "foo.exe" is OK but "foo" is an error.
24857   #
24858   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24859   # It is also a way to make sure we got the proper file name for the real test later on.
24860   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24861   if test "x$test_shortpath" = x; then
24862     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24863 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24864     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24865   fi
24866 
24867   # Call helper function which possibly converts this using DOS-style short mode.
24868   # If so, the updated path is stored in $new_path.
24869 
24870   input_path="$new_path"
24871   # Check if we need to convert this using DOS-style short mode. If the path
24872   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24873   # take no chances and rewrite it.
24874   # Note: m4 eats our [], so we need to use [ and ] instead.
24875   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24876   if test "x$has_forbidden_chars" != x; then
24877     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24878     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24879     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24880     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24881       # Going to short mode and back again did indeed matter. Since short mode is
24882       # case insensitive, let's make it lowercase to improve readability.
24883       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24884       # Now convert it back to Unix-stile (cygpath)
24885       input_path=`$CYGPATH -u "$shortmode_path"`
24886       new_path="$input_path"
24887     fi
24888   fi
24889 
24890   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24891   if test "x$test_cygdrive_prefix" = x; then
24892     # As a simple fix, exclude /usr/bin since it's not a real path.
24893     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; the