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 DISABLE_WARNING_PREFIX
 687 COMPILER_SUPPORTS_TARGET_BITS_FLAG
 688 ZERO_ARCHFLAG
 689 LDFLAGS_CXX_JDK
 690 LDFLAGS_JDKEXE_SUFFIX
 691 LDFLAGS_JDKLIB_SUFFIX
 692 LDFLAGS_JDKEXE
 693 LDFLAGS_JDKLIB
 694 CXXFLAGS_JDKEXE
 695 CXXFLAGS_JDKLIB
 696 CFLAGS_JDKEXE
 697 CFLAGS_JDKLIB
 698 MACOSX_VERSION_MIN
 699 LEGACY_EXTRA_LDFLAGS
 700 LEGACY_EXTRA_CXXFLAGS
 701 LEGACY_EXTRA_CFLAGS
 702 CXX_O_FLAG_NONE
 703 CXX_O_FLAG_DEBUG
 704 CXX_O_FLAG_NORM
 705 CXX_O_FLAG_HI
 706 CXX_O_FLAG_HIGHEST
 707 C_O_FLAG_NONE
 708 C_O_FLAG_DEBUG
 709 C_O_FLAG_NORM
 710 C_O_FLAG_HI
 711 C_O_FLAG_HIGHEST
 712 CXXFLAGS_DEBUG_OPTIONS
 713 CFLAGS_DEBUG_OPTIONS
 714 CXXFLAGS_DEBUG_SYMBOLS
 715 CFLAGS_DEBUG_SYMBOLS
 716 CXX_FLAG_DEPS
 717 C_FLAG_DEPS
 718 SET_SHARED_LIBRARY_MAPFILE
 719 SET_SHARED_LIBRARY_NAME
 720 SET_SHARED_LIBRARY_ORIGIN
 721 SET_EXECUTABLE_ORIGIN
 722 SHARED_LIBRARY_FLAGS
 723 CXX_FLAG_REORDER
 724 C_FLAG_REORDER
 725 SYSROOT_LDFLAGS
 726 SYSROOT_CFLAGS
 727 RC_FLAGS
 728 AR_OUT_OPTION
 729 LD_OUT_OPTION
 730 EXE_OUT_OPTION
 731 CC_OUT_OPTION
 732 POST_MCS_CMD
 733 POST_STRIP_CMD
 734 ARFLAGS
 735 COMPILER_TARGET_BITS_FLAG
 736 JT_HOME
 737 JTREGEXE
 738 USING_BROKEN_SUSE_LD
 739 PACKAGE_PATH
 740 LDEXECXX
 741 LDEXE
 742 USE_CLANG
 743 HOTSPOT_LD
 744 HOTSPOT_CXX
 745 HOTSPOT_RC
 746 HOTSPOT_MT
 747 BUILD_LD
 748 BUILD_CXX
 749 BUILD_CC
 750 ac_ct_OBJDUMP
 751 OBJDUMP
 752 ac_ct_OBJCOPY
 753 OBJCOPY
 754 ac_ct_NM
 755 ac_ct_STRIP
 756 MCS
 757 GNM
 758 NM
 759 STRIP
 760 MSBUILD
 761 DUMPBIN
 762 RC
 763 MT
 764 LIPO
 765 ac_ct_AR
 766 AR
 767 AS
 768 LDCXX
 769 LD
 770 CXXCPP
 771 CPP
 772 ac_ct_CXX
 773 CXXFLAGS
 774 CXX
 775 ac_ct_PROPER_COMPILER_CXX
 776 PROPER_COMPILER_CXX
 777 TOOLCHAIN_PATH_CXX
 778 POTENTIAL_CXX
 779 OBJEXT
 780 EXEEXT
 781 ac_ct_CC
 782 CPPFLAGS
 783 LDFLAGS
 784 CFLAGS
 785 CC
 786 ac_ct_PROPER_COMPILER_CC
 787 PROPER_COMPILER_CC
 788 TOOLCHAIN_PATH_CC
 789 POTENTIAL_CC
 790 VS_LIB
 791 VS_INCLUDE
 792 VS_PATH
 793 CYGWIN_LINK
 794 EXE_SUFFIX
 795 OBJ_SUFFIX
 796 STATIC_LIBRARY
 797 SHARED_LIBRARY
 798 STATIC_LIBRARY_SUFFIX
 799 SHARED_LIBRARY_SUFFIX
 800 LIBRARY_PREFIX
 801 TOOLCHAIN_TYPE
 802 BUILD_HOTSPOT
 803 HOTSPOT_DIST
 804 BUILD_OUTPUT
 805 OVERRIDE_SRC_ROOT
 806 ADD_SRC_ROOT
 807 JDK_TOPDIR
 808 NASHORN_TOPDIR
 809 HOTSPOT_TOPDIR
 810 JAXWS_TOPDIR
 811 JAXP_TOPDIR
 812 CORBA_TOPDIR
 813 LANGTOOLS_TOPDIR
 814 JAVAC_FLAGS
 815 BOOT_JDK_SOURCETARGET
 816 JARSIGNER
 817 NATIVE2ASCII
 818 JAR
 819 JAVAH
 820 JAVAC
 821 JAVA
 822 BOOT_JDK
 823 JAVA_CHECK
 824 JAVAC_CHECK
 825 COOKED_BUILD_NUMBER
 826 JDK_VERSION
 827 COPYRIGHT_YEAR
 828 MACOSX_BUNDLE_ID_BASE
 829 MACOSX_BUNDLE_NAME_BASE
 830 COMPANY_NAME
 831 JDK_RC_PLATFORM_NAME
 832 PRODUCT_SUFFIX
 833 PRODUCT_NAME
 834 LAUNCHER_NAME
 835 MILESTONE
 836 JDK_BUILD_NUMBER
 837 JDK_UPDATE_VERSION
 838 JDK_MICRO_VERSION
 839 JDK_MINOR_VERSION
 840 JDK_MAJOR_VERSION
 841 USER_RELEASE_SUFFIX
 842 COMPRESS_JARS
 843 RMICONNECTOR_IIOP
 844 UNLIMITED_CRYPTO
 845 CACERTS_FILE
 846 TEST_IN_BUILD
 847 BUILD_HEADLESS
 848 SUPPORT_HEADFUL
 849 SUPPORT_HEADLESS
 850 BDEPS_FTP
 851 BDEPS_UNZIP
 852 OS_VERSION_MICRO
 853 OS_VERSION_MINOR
 854 OS_VERSION_MAJOR
 855 PKG_CONFIG
 856 BASH_ARGS
 857 CODESIGN
 858 XATTR
 859 DSYMUTIL
 860 IS_GNU_TIME
 861 TIME
 862 STAT
 863 HG
 864 READELF
 865 OTOOL
 866 LDD
 867 ZIP
 868 UNZIP
 869 FIND_DELETE
 870 OUTPUT_SYNC
 871 OUTPUT_SYNC_SUPPORTED
 872 MAKE
 873 CHECK_TOOLSDIR_MAKE
 874 CHECK_TOOLSDIR_GMAKE
 875 CHECK_MAKE
 876 CHECK_GMAKE
 877 PKGHANDLER
 878 OUTPUT_ROOT
 879 CONF_NAME
 880 SPEC
 881 SDKROOT
 882 XCODEBUILD
 883 BUILD_VARIANT_RELEASE
 884 DEBUG_CLASSFILES
 885 FASTDEBUG
 886 VARIANT
 887 DEBUG_LEVEL
 888 MACOSX_UNIVERSAL
 889 INCLUDE_SA
 890 JVM_VARIANT_CORE
 891 JVM_VARIANT_ZEROSHARK
 892 JVM_VARIANT_ZERO
 893 JVM_VARIANT_KERNEL
 894 JVM_VARIANT_MINIMAL1
 895 JVM_VARIANT_CLIENT
 896 JVM_VARIANT_SERVER
 897 JVM_VARIANTS
 898 JVM_INTERPRETER
 899 JDK_VARIANT
 900 SET_OPENJDK
 901 BUILD_LOG_WRAPPER
 902 BUILD_LOG_PREVIOUS
 903 BUILD_LOG
 904 TOPDIR
 905 PATH_SEP
 906 ZERO_ARCHDEF
 907 DEFINE_CROSS_COMPILE_ARCH
 908 LP64
 909 OPENJDK_TARGET_OS_EXPORT_DIR
 910 OPENJDK_TARGET_CPU_JLI_CFLAGS
 911 OPENJDK_TARGET_CPU_OSARCH
 912 OPENJDK_TARGET_CPU_ISADIR
 913 OPENJDK_TARGET_CPU_LIBDIR
 914 OPENJDK_TARGET_CPU_LEGACY_LIB
 915 OPENJDK_TARGET_CPU_LEGACY
 916 REQUIRED_OS_VERSION
 917 REQUIRED_OS_NAME
 918 COMPILE_TYPE
 919 OPENJDK_TARGET_CPU_ENDIAN
 920 OPENJDK_TARGET_CPU_BITS
 921 OPENJDK_TARGET_CPU_ARCH
 922 OPENJDK_TARGET_CPU
 923 OPENJDK_TARGET_OS_ENV
 924 OPENJDK_TARGET_OS_TYPE
 925 OPENJDK_TARGET_OS
 926 OPENJDK_BUILD_CPU_ENDIAN
 927 OPENJDK_BUILD_CPU_BITS
 928 OPENJDK_BUILD_CPU_ARCH
 929 OPENJDK_BUILD_CPU
 930 OPENJDK_BUILD_OS_ENV
 931 OPENJDK_BUILD_OS_TYPE
 932 OPENJDK_BUILD_OS
 933 OPENJDK_BUILD_AUTOCONF_NAME
 934 OPENJDK_TARGET_AUTOCONF_NAME
 935 target_os
 936 target_vendor
 937 target_cpu
 938 target
 939 host_os
 940 host_vendor
 941 host_cpu
 942 host
 943 build_os
 944 build_vendor
 945 build_cpu
 946 build
 947 CPIO
 948 SETFILE
 949 DF
 950 READLINK
 951 CYGPATH
 952 SED
 953 FGREP
 954 EGREP
 955 GREP
 956 AWK
 957 XARGS
 958 WHICH
 959 WC
 960 UNIQ
 961 UNAME
 962 TR
 963 TOUCH
 964 TEE
 965 TAR
 966 TAIL
 967 SORT
 968 SH
 969 RM
 970 PRINTF
 971 NAWK
 972 MV
 973 MKTEMP
 974 MKDIR
 975 LS
 976 LN
 977 HEAD
 978 FIND
 979 FILE
 980 EXPR
 981 ECHO
 982 DIRNAME
 983 DIFF
 984 DATE
 985 CUT
 986 CP
 987 COMM
 988 CMP
 989 CHMOD
 990 CAT
 991 BASH
 992 BASENAME
 993 DATE_WHEN_CONFIGURED
 994 ORIGINAL_PATH
 995 CONFIGURE_COMMAND_LINE
 996 target_alias
 997 host_alias
 998 build_alias
 999 LIBS
1000 ECHO_T
1001 ECHO_N
1002 ECHO_C
1003 DEFS
1004 mandir
1005 localedir
1006 libdir
1007 psdir
1008 pdfdir
1009 dvidir
1010 htmldir
1011 infodir
1012 docdir
1013 oldincludedir
1014 includedir
1015 localstatedir
1016 sharedstatedir
1017 sysconfdir
1018 datadir
1019 datarootdir
1020 libexecdir
1021 sbindir
1022 bindir
1023 program_transform_name
1024 prefix
1025 exec_prefix
1026 PACKAGE_URL
1027 PACKAGE_BUGREPORT
1028 PACKAGE_STRING
1029 PACKAGE_VERSION
1030 PACKAGE_TARNAME
1031 PACKAGE_NAME
1032 PATH_SEPARATOR
1033 SHELL'
1034 ac_subst_files=''
1035 ac_user_opts='
1036 enable_option_checking
1037 with_target_bits
1038 enable_openjdk_only
1039 with_custom_make_dir
1040 with_jdk_variant
1041 with_jvm_interpreter
1042 with_jvm_variants
1043 enable_debug
1044 with_debug_level
1045 with_devkit
1046 with_sys_root
1047 with_sysroot
1048 with_tools_dir
1049 with_toolchain_path
1050 with_extra_path
1051 with_sdk_name
1052 with_conf_name
1053 with_output_sync
1054 with_builddeps_conf
1055 with_builddeps_server
1056 with_builddeps_dir
1057 with_builddeps_group
1058 enable_headful
1059 enable_hotspot_test_in_build
1060 with_cacerts_file
1061 enable_unlimited_crypto
1062 enable_rmiconnector_iiop
1063 with_milestone
1064 with_update_version
1065 with_user_release_suffix
1066 with_build_number
1067 with_copyright_year
1068 with_boot_jdk
1069 with_add_source_root
1070 with_override_source_root
1071 with_adds_and_overrides
1072 with_override_langtools
1073 with_override_corba
1074 with_override_jaxp
1075 with_override_jaxws
1076 with_override_hotspot
1077 with_override_nashorn
1078 with_override_jdk
1079 with_import_hotspot
1080 with_toolchain_type
1081 with_toolchain_version
1082 with_jtreg
1083 with_extra_cflags
1084 with_extra_cxxflags
1085 with_extra_ldflags
1086 enable_debug_symbols
1087 enable_zip_debug_info
1088 with_x
1089 with_cups
1090 with_cups_include
1091 with_freetype
1092 with_freetype_include
1093 with_freetype_lib
1094 with_freetype_src
1095 enable_freetype_bundling
1096 with_alsa
1097 with_alsa_include
1098 with_alsa_lib
1099 with_libjpeg
1100 with_giflib
1101 with_lcms
1102 with_libpng
1103 with_zlib
1104 with_stdc__lib
1105 with_msvcr_dll
1106 with_msvcp_dll
1107 with_dxsdk
1108 with_dxsdk_lib
1109 with_dxsdk_include
1110 with_num_cores
1111 with_memory_size
1112 with_jobs
1113 with_boot_jdk_jvmargs
1114 with_sjavac_server_java
1115 enable_sjavac
1116 enable_precompiled_headers
1117 enable_ccache
1118 with_ccache_dir
1119 '
1120       ac_precious_vars='build_alias
1121 host_alias
1122 target_alias
1123 BASENAME
1124 BASH
1125 CAT
1126 CHMOD
1127 CMP
1128 COMM
1129 CP
1130 CUT
1131 DATE
1132 DIFF
1133 DIRNAME
1134 ECHO
1135 EXPR
1136 FILE
1137 FIND
1138 HEAD
1139 LN
1140 LS
1141 MKDIR
1142 MKTEMP
1143 MV
1144 NAWK
1145 PRINTF
1146 RM
1147 SH
1148 SORT
1149 TAIL
1150 TAR
1151 TEE
1152 TOUCH
1153 TR
1154 UNAME
1155 UNIQ
1156 WC
1157 WHICH
1158 XARGS
1159 AWK
1160 GREP
1161 EGREP
1162 FGREP
1163 SED
1164 CYGPATH
1165 READLINK
1166 DF
1167 SETFILE
1168 CPIO
1169 UNZIP
1170 ZIP
1171 LDD
1172 OTOOL
1173 READELF
1174 HG
1175 STAT
1176 TIME
1177 DSYMUTIL
1178 XATTR
1179 CODESIGN
1180 PKG_CONFIG
1181 JAVA
1182 JAVAC
1183 JAVAH
1184 JAR
1185 NATIVE2ASCII
1186 JARSIGNER
1187 CC
1188 CFLAGS
1189 LDFLAGS
1190 LIBS
1191 CPPFLAGS
1192 CXX
1193 CXXFLAGS
1194 CCC
1195 CPP
1196 CXXCPP
1197 AS
1198 AR
1199 LIPO
1200 STRIP
1201 NM
1202 GNM
1203 MCS
1204 OBJCOPY
1205 OBJDUMP
1206 BUILD_CC
1207 BUILD_CXX
1208 BUILD_LD
1209 JTREGEXE
1210 XMKMF
1211 FREETYPE_CFLAGS
1212 FREETYPE_LIBS
1213 ALSA_CFLAGS
1214 ALSA_LIBS
1215 LCMS_CFLAGS
1216 LCMS_LIBS
1217 PNG_CFLAGS
1218 PNG_LIBS
1219 LIBFFI_CFLAGS
1220 LIBFFI_LIBS
1221 CCACHE'
1222 
1223 
1224 # Initialize some variables set by options.
1225 ac_init_help=
1226 ac_init_version=false
1227 ac_unrecognized_opts=
1228 ac_unrecognized_sep=
1229 # The variables have the same names as the options, with
1230 # dashes changed to underlines.
1231 cache_file=/dev/null
1232 exec_prefix=NONE
1233 no_create=
1234 no_recursion=
1235 prefix=NONE
1236 program_prefix=NONE
1237 program_suffix=NONE
1238 program_transform_name=s,x,x,
1239 silent=
1240 site=
1241 srcdir=
1242 verbose=
1243 x_includes=NONE
1244 x_libraries=NONE
1245 
1246 # Installation directory options.
1247 # These are left unexpanded so users can "make install exec_prefix=/foo"
1248 # and all the variables that are supposed to be based on exec_prefix
1249 # by default will actually change.
1250 # Use braces instead of parens because sh, perl, etc. also accept them.
1251 # (The list follows the same order as the GNU Coding Standards.)
1252 bindir='${exec_prefix}/bin'
1253 sbindir='${exec_prefix}/sbin'
1254 libexecdir='${exec_prefix}/libexec'
1255 datarootdir='${prefix}/share'
1256 datadir='${datarootdir}'
1257 sysconfdir='${prefix}/etc'
1258 sharedstatedir='${prefix}/com'
1259 localstatedir='${prefix}/var'
1260 includedir='${prefix}/include'
1261 oldincludedir='/usr/include'
1262 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
1263 infodir='${datarootdir}/info'
1264 htmldir='${docdir}'
1265 dvidir='${docdir}'
1266 pdfdir='${docdir}'
1267 psdir='${docdir}'
1268 libdir='${exec_prefix}/lib'
1269 localedir='${datarootdir}/locale'
1270 mandir='${datarootdir}/man'
1271 
1272 ac_prev=
1273 ac_dashdash=
1274 for ac_option
1275 do
1276   # If the previous option needs an argument, assign it.
1277   if test -n "$ac_prev"; then
1278     eval $ac_prev=\$ac_option
1279     ac_prev=
1280     continue
1281   fi
1282 
1283   case $ac_option in
1284   *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
1285   *=)   ac_optarg= ;;
1286   *)    ac_optarg=yes ;;
1287   esac
1288 
1289   # Accept the important Cygnus configure options, so we can diagnose typos.
1290 
1291   case $ac_dashdash$ac_option in
1292   --)
1293     ac_dashdash=yes ;;
1294 
1295   -bindir | --bindir | --bindi | --bind | --bin | --bi)
1296     ac_prev=bindir ;;
1297   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
1298     bindir=$ac_optarg ;;
1299 
1300   -build | --build | --buil | --bui | --bu)
1301     ac_prev=build_alias ;;
1302   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
1303     build_alias=$ac_optarg ;;
1304 
1305   -cache-file | --cache-file | --cache-fil | --cache-fi \
1306   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
1307     ac_prev=cache_file ;;
1308   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
1309   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
1310     cache_file=$ac_optarg ;;
1311 
1312   --config-cache | -C)
1313     cache_file=config.cache ;;
1314 
1315   -datadir | --datadir | --datadi | --datad)
1316     ac_prev=datadir ;;
1317   -datadir=* | --datadir=* | --datadi=* | --datad=*)
1318     datadir=$ac_optarg ;;
1319 
1320   -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
1321   | --dataroo | --dataro | --datar)
1322     ac_prev=datarootdir ;;
1323   -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
1324   | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
1325     datarootdir=$ac_optarg ;;
1326 
1327   -disable-* | --disable-*)
1328     ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
1329     # Reject names that are not valid shell variable names.
1330     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1331       as_fn_error $? "invalid feature name: $ac_useropt"
1332     ac_useropt_orig=$ac_useropt
1333     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1334     case $ac_user_opts in
1335       *"
1336 "enable_$ac_useropt"
1337 "*) ;;
1338       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
1339          ac_unrecognized_sep=', ';;
1340     esac
1341     eval enable_$ac_useropt=no ;;
1342 
1343   -docdir | --docdir | --docdi | --doc | --do)
1344     ac_prev=docdir ;;
1345   -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
1346     docdir=$ac_optarg ;;
1347 
1348   -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
1349     ac_prev=dvidir ;;
1350   -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
1351     dvidir=$ac_optarg ;;
1352 
1353   -enable-* | --enable-*)
1354     ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
1355     # Reject names that are not valid shell variable names.
1356     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1357       as_fn_error $? "invalid feature name: $ac_useropt"
1358     ac_useropt_orig=$ac_useropt
1359     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1360     case $ac_user_opts in
1361       *"
1362 "enable_$ac_useropt"
1363 "*) ;;
1364       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
1365          ac_unrecognized_sep=', ';;
1366     esac
1367     eval enable_$ac_useropt=\$ac_optarg ;;
1368 
1369   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
1370   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
1371   | --exec | --exe | --ex)
1372     ac_prev=exec_prefix ;;
1373   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
1374   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
1375   | --exec=* | --exe=* | --ex=*)
1376     exec_prefix=$ac_optarg ;;
1377 
1378   -gas | --gas | --ga | --g)
1379     # Obsolete; use --with-gas.
1380     with_gas=yes ;;
1381 
1382   -help | --help | --hel | --he | -h)
1383     ac_init_help=long ;;
1384   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
1385     ac_init_help=recursive ;;
1386   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
1387     ac_init_help=short ;;
1388 
1389   -host | --host | --hos | --ho)
1390     ac_prev=host_alias ;;
1391   -host=* | --host=* | --hos=* | --ho=*)
1392     host_alias=$ac_optarg ;;
1393 
1394   -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
1395     ac_prev=htmldir ;;
1396   -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
1397   | --ht=*)
1398     htmldir=$ac_optarg ;;
1399 
1400   -includedir | --includedir | --includedi | --included | --include \
1401   | --includ | --inclu | --incl | --inc)
1402     ac_prev=includedir ;;
1403   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
1404   | --includ=* | --inclu=* | --incl=* | --inc=*)
1405     includedir=$ac_optarg ;;
1406 
1407   -infodir | --infodir | --infodi | --infod | --info | --inf)
1408     ac_prev=infodir ;;
1409   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
1410     infodir=$ac_optarg ;;
1411 
1412   -libdir | --libdir | --libdi | --libd)
1413     ac_prev=libdir ;;
1414   -libdir=* | --libdir=* | --libdi=* | --libd=*)
1415     libdir=$ac_optarg ;;
1416 
1417   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
1418   | --libexe | --libex | --libe)
1419     ac_prev=libexecdir ;;
1420   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
1421   | --libexe=* | --libex=* | --libe=*)
1422     libexecdir=$ac_optarg ;;
1423 
1424   -localedir | --localedir | --localedi | --localed | --locale)
1425     ac_prev=localedir ;;
1426   -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
1427     localedir=$ac_optarg ;;
1428 
1429   -localstatedir | --localstatedir | --localstatedi | --localstated \
1430   | --localstate | --localstat | --localsta | --localst | --locals)
1431     ac_prev=localstatedir ;;
1432   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
1433   | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
1434     localstatedir=$ac_optarg ;;
1435 
1436   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
1437     ac_prev=mandir ;;
1438   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
1439     mandir=$ac_optarg ;;
1440 
1441   -nfp | --nfp | --nf)
1442     # Obsolete; use --without-fp.
1443     with_fp=no ;;
1444 
1445   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
1446   | --no-cr | --no-c | -n)
1447     no_create=yes ;;
1448 
1449   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
1450   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
1451     no_recursion=yes ;;
1452 
1453   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
1454   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
1455   | --oldin | --oldi | --old | --ol | --o)
1456     ac_prev=oldincludedir ;;
1457   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
1458   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
1459   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
1460     oldincludedir=$ac_optarg ;;
1461 
1462   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
1463     ac_prev=prefix ;;
1464   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
1465     prefix=$ac_optarg ;;
1466 
1467   -program-prefix | --program-prefix | --program-prefi | --program-pref \
1468   | --program-pre | --program-pr | --program-p)
1469     ac_prev=program_prefix ;;
1470   -program-prefix=* | --program-prefix=* | --program-prefi=* \
1471   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
1472     program_prefix=$ac_optarg ;;
1473 
1474   -program-suffix | --program-suffix | --program-suffi | --program-suff \
1475   | --program-suf | --program-su | --program-s)
1476     ac_prev=program_suffix ;;
1477   -program-suffix=* | --program-suffix=* | --program-suffi=* \
1478   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
1479     program_suffix=$ac_optarg ;;
1480 
1481   -program-transform-name | --program-transform-name \
1482   | --program-transform-nam | --program-transform-na \
1483   | --program-transform-n | --program-transform- \
1484   | --program-transform | --program-transfor \
1485   | --program-transfo | --program-transf \
1486   | --program-trans | --program-tran \
1487   | --progr-tra | --program-tr | --program-t)
1488     ac_prev=program_transform_name ;;
1489   -program-transform-name=* | --program-transform-name=* \
1490   | --program-transform-nam=* | --program-transform-na=* \
1491   | --program-transform-n=* | --program-transform-=* \
1492   | --program-transform=* | --program-transfor=* \
1493   | --program-transfo=* | --program-transf=* \
1494   | --program-trans=* | --program-tran=* \
1495   | --progr-tra=* | --program-tr=* | --program-t=*)
1496     program_transform_name=$ac_optarg ;;
1497 
1498   -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
1499     ac_prev=pdfdir ;;
1500   -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
1501     pdfdir=$ac_optarg ;;
1502 
1503   -psdir | --psdir | --psdi | --psd | --ps)
1504     ac_prev=psdir ;;
1505   -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
1506     psdir=$ac_optarg ;;
1507 
1508   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1509   | -silent | --silent | --silen | --sile | --sil)
1510     silent=yes ;;
1511 
1512   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
1513     ac_prev=sbindir ;;
1514   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
1515   | --sbi=* | --sb=*)
1516     sbindir=$ac_optarg ;;
1517 
1518   -sharedstatedir | --sharedstatedir | --sharedstatedi \
1519   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
1520   | --sharedst | --shareds | --shared | --share | --shar \
1521   | --sha | --sh)
1522     ac_prev=sharedstatedir ;;
1523   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
1524   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
1525   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
1526   | --sha=* | --sh=*)
1527     sharedstatedir=$ac_optarg ;;
1528 
1529   -site | --site | --sit)
1530     ac_prev=site ;;
1531   -site=* | --site=* | --sit=*)
1532     site=$ac_optarg ;;
1533 
1534   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
1535     ac_prev=srcdir ;;
1536   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
1537     srcdir=$ac_optarg ;;
1538 
1539   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
1540   | --syscon | --sysco | --sysc | --sys | --sy)
1541     ac_prev=sysconfdir ;;
1542   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
1543   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
1544     sysconfdir=$ac_optarg ;;
1545 
1546   -target | --target | --targe | --targ | --tar | --ta | --t)
1547     ac_prev=target_alias ;;
1548   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
1549     target_alias=$ac_optarg ;;
1550 
1551   -v | -verbose | --verbose | --verbos | --verbo | --verb)
1552     verbose=yes ;;
1553 
1554   -version | --version | --versio | --versi | --vers | -V)
1555     ac_init_version=: ;;
1556 
1557   -with-* | --with-*)
1558     ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1559     # Reject names that are not valid shell variable names.
1560     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1561       as_fn_error $? "invalid package name: $ac_useropt"
1562     ac_useropt_orig=$ac_useropt
1563     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1564     case $ac_user_opts in
1565       *"
1566 "with_$ac_useropt"
1567 "*) ;;
1568       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
1569          ac_unrecognized_sep=', ';;
1570     esac
1571     eval with_$ac_useropt=\$ac_optarg ;;
1572 
1573   -without-* | --without-*)
1574     ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1575     # Reject names that are not valid shell variable names.
1576     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1577       as_fn_error $? "invalid package name: $ac_useropt"
1578     ac_useropt_orig=$ac_useropt
1579     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1580     case $ac_user_opts in
1581       *"
1582 "with_$ac_useropt"
1583 "*) ;;
1584       *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
1585          ac_unrecognized_sep=', ';;
1586     esac
1587     eval with_$ac_useropt=no ;;
1588 
1589   --x)
1590     # Obsolete; use --with-x.
1591     with_x=yes ;;
1592 
1593   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
1594   | --x-incl | --x-inc | --x-in | --x-i)
1595     ac_prev=x_includes ;;
1596   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
1597   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
1598     x_includes=$ac_optarg ;;
1599 
1600   -x-libraries | --x-libraries | --x-librarie | --x-librari \
1601   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
1602     ac_prev=x_libraries ;;
1603   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
1604   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1605     x_libraries=$ac_optarg ;;
1606 
1607   -*) as_fn_error $? "unrecognized option: \`$ac_option'
1608 Try \`$0 --help' for more information"
1609     ;;
1610 
1611   *=*)
1612     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1613     # Reject names that are not valid shell variable names.
1614     case $ac_envvar in #(
1615       '' | [0-9]* | *[!_$as_cr_alnum]* )
1616       as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1617     esac
1618     eval $ac_envvar=\$ac_optarg
1619     export $ac_envvar ;;
1620 
1621   *)
1622     # FIXME: should be removed in autoconf 3.0.
1623     $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1624     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1625       $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1626     : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1627     ;;
1628 
1629   esac
1630 done
1631 
1632 if test -n "$ac_prev"; then
1633   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1634   as_fn_error $? "missing argument to $ac_option"
1635 fi
1636 
1637 if test -n "$ac_unrecognized_opts"; then
1638   case $enable_option_checking in
1639     no) ;;
1640     fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1641     *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1642   esac
1643 fi
1644 
1645 # Check all directory arguments for consistency.
1646 for ac_var in   exec_prefix prefix bindir sbindir libexecdir datarootdir \
1647                 datadir sysconfdir sharedstatedir localstatedir includedir \
1648                 oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
1649                 libdir localedir mandir
1650 do
1651   eval ac_val=\$$ac_var
1652   # Remove trailing slashes.
1653   case $ac_val in
1654     */ )
1655       ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
1656       eval $ac_var=\$ac_val;;
1657   esac
1658   # Be sure to have absolute directory names.
1659   case $ac_val in
1660     [\\/$]* | ?:[\\/]* )  continue;;
1661     NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1662   esac
1663   as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1664 done
1665 
1666 # There might be people who depend on the old broken behavior: `$host'
1667 # used to hold the argument of --host etc.
1668 # FIXME: To remove some day.
1669 build=$build_alias
1670 host=$host_alias
1671 target=$target_alias
1672 
1673 # FIXME: To remove some day.
1674 if test "x$host_alias" != x; then
1675   if test "x$build_alias" = x; then
1676     cross_compiling=maybe
1677   elif test "x$build_alias" != "x$host_alias"; then
1678     cross_compiling=yes
1679   fi
1680 fi
1681 
1682 ac_tool_prefix=
1683 test -n "$host_alias" && ac_tool_prefix=$host_alias-
1684 
1685 test "$silent" = yes && exec 6>/dev/null
1686 
1687 
1688 ac_pwd=`pwd` && test -n "$ac_pwd" &&
1689 ac_ls_di=`ls -di .` &&
1690 ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1691   as_fn_error $? "working directory cannot be determined"
1692 test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1693   as_fn_error $? "pwd does not report name of working directory"
1694 
1695 
1696 # Find the source files, if location was not specified.
1697 if test -z "$srcdir"; then
1698   ac_srcdir_defaulted=yes
1699   # Try the directory containing this script, then the parent directory.
1700   ac_confdir=`$as_dirname -- "$as_myself" ||
1701 $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1702          X"$as_myself" : 'X\(//\)[^/]' \| \
1703          X"$as_myself" : 'X\(//\)$' \| \
1704          X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
1705 $as_echo X"$as_myself" |
1706     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
1707             s//\1/
1708             q
1709           }
1710           /^X\(\/\/\)[^/].*/{
1711             s//\1/
1712             q
1713           }
1714           /^X\(\/\/\)$/{
1715             s//\1/
1716             q
1717           }
1718           /^X\(\/\).*/{
1719             s//\1/
1720             q
1721           }
1722           s/.*/./; q'`
1723   srcdir=$ac_confdir
1724   if test ! -r "$srcdir/$ac_unique_file"; then
1725     srcdir=..
1726   fi
1727 else
1728   ac_srcdir_defaulted=no
1729 fi
1730 if test ! -r "$srcdir/$ac_unique_file"; then
1731   test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1732   as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1733 fi
1734 ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1735 ac_abs_confdir=`(
1736         cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1737         pwd)`
1738 # When building in place, set srcdir=.
1739 if test "$ac_abs_confdir" = "$ac_pwd"; then
1740   srcdir=.
1741 fi
1742 # Remove unnecessary trailing slashes from srcdir.
1743 # Double slashes in file names in object file debugging info
1744 # mess up M-x gdb in Emacs.
1745 case $srcdir in
1746 */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
1747 esac
1748 for ac_var in $ac_precious_vars; do
1749   eval ac_env_${ac_var}_set=\${${ac_var}+set}
1750   eval ac_env_${ac_var}_value=\$${ac_var}
1751   eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
1752   eval ac_cv_env_${ac_var}_value=\$${ac_var}
1753 done
1754 
1755 #
1756 # Report the --help message.
1757 #
1758 if test "$ac_init_help" = "long"; then
1759   # Omit some internal or obsolete options to make the list less imposing.
1760   # This message is too long to be a string in the A/UX 3.1 sh.
1761   cat <<_ACEOF
1762 \`configure' configures OpenJDK jdk9 to adapt to many kinds of systems.
1763 
1764 Usage: $0 [OPTION]... [VAR=VALUE]...
1765 
1766 To assign environment variables (e.g., CC, CFLAGS...), specify them as
1767 VAR=VALUE.  See below for descriptions of some of the useful variables.
1768 
1769 Defaults for the options are specified in brackets.
1770 
1771 Configuration:
1772   -h, --help              display this help and exit
1773       --help=short        display options specific to this package
1774       --help=recursive    display the short help of all the included packages
1775   -V, --version           display version information and exit
1776   -q, --quiet, --silent   do not print \`checking ...' messages
1777       --cache-file=FILE   cache test results in FILE [disabled]
1778   -C, --config-cache      alias for \`--cache-file=config.cache'
1779   -n, --no-create         do not create output files
1780       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
1781 
1782 Installation directories:
1783   --prefix=PREFIX         install architecture-independent files in PREFIX
1784                           [$ac_default_prefix]
1785   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
1786                           [PREFIX]
1787 
1788 By default, \`make install' will install all the files in
1789 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
1790 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
1791 for instance \`--prefix=\$HOME'.
1792 
1793 For better control, use the options below.
1794 
1795 Fine tuning of the installation directories:
1796   --bindir=DIR            user executables [EPREFIX/bin]
1797   --sbindir=DIR           system admin executables [EPREFIX/sbin]
1798   --libexecdir=DIR        program executables [EPREFIX/libexec]
1799   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
1800   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
1801   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
1802   --libdir=DIR            object code libraries [EPREFIX/lib]
1803   --includedir=DIR        C header files [PREFIX/include]
1804   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
1805   --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
1806   --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
1807   --infodir=DIR           info documentation [DATAROOTDIR/info]
1808   --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
1809   --mandir=DIR            man documentation [DATAROOTDIR/man]
1810   --docdir=DIR            documentation root [DATAROOTDIR/doc/openjdk]
1811   --htmldir=DIR           html documentation [DOCDIR]
1812   --dvidir=DIR            dvi documentation [DOCDIR]
1813   --pdfdir=DIR            pdf documentation [DOCDIR]
1814   --psdir=DIR             ps documentation [DOCDIR]
1815 _ACEOF
1816 
1817   cat <<\_ACEOF
1818 
1819 X features:
1820   --x-includes=DIR    X include files are in DIR
1821   --x-libraries=DIR   X library files are in DIR
1822 
1823 System types:
1824   --build=BUILD     configure for building on BUILD [guessed]
1825   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
1826   --target=TARGET   configure for building compilers for TARGET [HOST]
1827 _ACEOF
1828 fi
1829 
1830 if test -n "$ac_init_help"; then
1831   case $ac_init_help in
1832      short | recursive ) echo "Configuration of OpenJDK jdk9:";;
1833    esac
1834   cat <<\_ACEOF
1835 
1836 Optional Features:
1837   --disable-option-checking  ignore unrecognized --enable/--with options
1838   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1839   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
1840   --enable-openjdk-only   suppress building custom source even if present
1841                           [disabled]
1842   --enable-debug          set the debug level to fastdebug (shorthand for
1843                           --with-debug-level=fastdebug) [disabled]
1844   --disable-headful       disable building headful support (graphical UI
1845                           support) [enabled]
1846   --enable-hotspot-test-in-build
1847                           run the Queens test after Hotspot build [disabled]
1848   --enable-unlimited-crypto
1849                           Enable unlimited crypto policy [disabled]
1850   --enable-rmiconnector-iiop
1851                           enable the JMX RMIConnector iiop transport
1852                           [disabled]
1853   --disable-debug-symbols disable generation of debug symbols [enabled]
1854   --disable-zip-debug-info
1855                           disable zipping of debug-info files [enabled]
1856   --disable-freetype-bundling
1857                           disable bundling of the freetype library with the
1858                           build result [enabled on Windows or when using
1859                           --with-freetype, disabled otherwise]
1860   --enable-sjavac         use sjavac to do fast incremental compiles
1861                           [disabled]
1862   --disable-precompiled-headers
1863                           disable using precompiled headers when compiling C++
1864                           [enabled]
1865   --enable-ccache         enable using ccache to speed up recompilations
1866                           [disabled]
1867 
1868 Optional Packages:
1869   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1870   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
1871   --with-target-bits      build 32-bit or 64-bit binaries (for platforms that
1872                           support it), e.g. --with-target-bits=32 [guessed]
1873   --with-custom-make-dir  Deprecated. Option is kept for backwards
1874                           compatibility and is ignored
1875   --with-jdk-variant      JDK variant to build (normal) [normal]
1876   --with-jvm-interpreter  JVM interpreter to build (template, cpp) [template]
1877   --with-jvm-variants     JVM variants (separated by commas) to build (server,
1878                           client, minimal1, kernel, zero, zeroshark, core)
1879                           [server]
1880   --with-debug-level      set the debug level (release, fastdebug, slowdebug,
1881                           optimized (HotSpot build only)) [release]
1882   --with-devkit           use this devkit for compilers, tools and resources
1883   --with-sys-root         alias for --with-sysroot for backwards compatability
1884   --with-sysroot          use this directory as sysroot
1885   --with-tools-dir        alias for --with-toolchain-path for backwards
1886                           compatibility
1887   --with-toolchain-path   prepend these directories when searching for
1888                           toolchain binaries (compilers etc)
1889   --with-extra-path       prepend these directories to the default path
1890   --with-sdk-name         use the platform SDK of the given name. [macosx]
1891   --with-conf-name        use this as the name of the configuration [generated
1892                           from important configuration options]
1893   --with-output-sync      set make output sync type if supported by make.
1894                           [recurse]
1895   --with-builddeps-conf   use this configuration file for the builddeps
1896   --with-builddeps-server download and use build dependencies from this server
1897                           url
1898   --with-builddeps-dir    store downloaded build dependencies here
1899                           [/localhome/builddeps]
1900   --with-builddeps-group  chgrp the downloaded build dependencies to this
1901                           group
1902   --with-cacerts-file     specify alternative cacerts file
1903   --with-milestone        Set milestone value for build [internal]
1904   --with-update-version   Set update version value for build [b00]
1905   --with-user-release-suffix
1906                           Add a custom string to the version string if build
1907                           number is not set.[username_builddateb00]
1908   --with-build-number     Set build number value for build [b00]
1909   --with-copyright-year   Set copyright year value for build [current year]
1910   --with-boot-jdk         path to Boot JDK (used to bootstrap build) [probed]
1911   --with-add-source-root  for each and every source directory, look in this
1912                           additional source root for the same directory; if it
1913                           exists and have files in it, include it in the build
1914   --with-override-source-root
1915                           for each and every source directory, look in this
1916                           override source root for the same directory; if it
1917                           exists, use that directory instead and ignore the
1918                           directory in the original source root
1919   --with-adds-and-overrides
1920                           use the subdirs 'adds' and 'overrides' in the
1921                           specified directory as add-source-root and
1922                           override-source-root
1923   --with-override-langtools
1924                           use this langtools dir for the build
1925   --with-override-corba   use this corba dir for the build
1926   --with-override-jaxp    use this jaxp dir for the build
1927   --with-override-jaxws   use this jaxws dir for the build
1928   --with-override-hotspot use this hotspot dir for the build
1929   --with-override-nashorn use this nashorn dir for the build
1930   --with-override-jdk     use this jdk dir for the build
1931   --with-import-hotspot   import hotspot binaries from this jdk image or
1932                           hotspot build dist dir instead of building from
1933                           source
1934   --with-toolchain-type   the toolchain type (or family) to use, use '--help'
1935                           to show possible values [platform dependent]
1936   --with-toolchain-version
1937                           the version of the toolchain to look for, use
1938                           '--help' to show possible values [platform
1939                           dependent]
1940   --with-jtreg            Regression Test Harness [probed]
1941   --with-extra-cflags     extra flags to be used when compiling jdk c-files
1942   --with-extra-cxxflags   extra flags to be used when compiling jdk c++-files
1943   --with-extra-ldflags    extra flags to be used when linking jdk
1944   --with-x                use the X Window System
1945   --with-cups             specify prefix directory for the cups package
1946                           (expecting the headers under PATH/include)
1947   --with-cups-include     specify directory for the cups include files
1948   --with-freetype         specify prefix directory for the freetype package
1949                           (expecting the libraries under PATH/lib and the
1950                           headers under PATH/include)
1951   --with-freetype-include specify directory for the freetype include files
1952   --with-freetype-lib     specify directory for the freetype library
1953   --with-freetype-src     specify directory with freetype sources to
1954                           automatically build the library (experimental,
1955                           Windows-only)
1956   --with-alsa             specify prefix directory for the alsa package
1957                           (expecting the libraries under PATH/lib and the
1958                           headers under PATH/include)
1959   --with-alsa-include     specify directory for the alsa include files
1960   --with-alsa-lib         specify directory for the alsa library
1961   --with-libjpeg          use libjpeg from build system or OpenJDK source
1962                           (system, bundled) [bundled]
1963   --with-giflib           use giflib from build system or OpenJDK source
1964                           (system, bundled) [bundled]
1965   --with-lcms             use lcms2 from build system or OpenJDK source
1966                           (system, bundled) [bundled]
1967   --with-libpng           use libpng from build system or OpenJDK source
1968                           (system, bundled) [bundled]
1969   --with-zlib             use zlib from build system or OpenJDK source
1970                           (system, bundled) [bundled]
1971   --with-stdc++lib=<static>,<dynamic>,<default>
1972                           force linking of the C++ runtime on Linux to either
1973                           static or dynamic, default is static with dynamic as
1974                           fallback
1975   --with-msvcr-dll        path to microsoft C runtime dll (msvcr*.dll)
1976                           (Windows only) [probed]
1977   --with-msvcp-dll        path to microsoft C++ runtime dll (msvcp*.dll)
1978                           (Windows only) [probed]
1979   --with-dxsdk            Deprecated. Option is kept for backwards
1980                           compatibility and is ignored
1981   --with-dxsdk-lib        Deprecated. Option is kept for backwards
1982                           compatibility and is ignored
1983   --with-dxsdk-include    Deprecated. Option is kept for backwards
1984                           compatibility and is ignored
1985   --with-num-cores        number of cores in the build system, e.g.
1986                           --with-num-cores=8 [probed]
1987   --with-memory-size      memory (in MB) available in the build system, e.g.
1988                           --with-memory-size=1024 [probed]
1989   --with-jobs             number of parallel jobs to let make run [calculated
1990                           based on cores and memory]
1991   --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
1992                           invocations of boot JDK, overriding the default
1993                           values, e.g --with-boot-jdk-jvmargs="-Xmx8G
1994                           -enableassertions"
1995   --with-sjavac-server-java
1996                           use this java binary for running the sjavac
1997                           background server [Boot JDK java]
1998   --with-ccache-dir       where to store ccache files [~/.ccache]
1999 
2000 Some influential environment variables:
2001   BASENAME    Override default value for BASENAME
2002   BASH        Override default value for BASH
2003   CAT         Override default value for CAT
2004   CHMOD       Override default value for CHMOD
2005   CMP         Override default value for CMP
2006   COMM        Override default value for COMM
2007   CP          Override default value for CP
2008   CUT         Override default value for CUT
2009   DATE        Override default value for DATE
2010   DIFF        Override default value for DIFF
2011   DIRNAME     Override default value for DIRNAME
2012   ECHO        Override default value for ECHO
2013   EXPR        Override default value for EXPR
2014   FILE        Override default value for FILE
2015   FIND        Override default value for FIND
2016   HEAD        Override default value for HEAD
2017   LN          Override default value for LN
2018   LS          Override default value for LS
2019   MKDIR       Override default value for MKDIR
2020   MKTEMP      Override default value for MKTEMP
2021   MV          Override default value for MV
2022   NAWK        Override default value for NAWK
2023   PRINTF      Override default value for PRINTF
2024   RM          Override default value for RM
2025   SH          Override default value for SH
2026   SORT        Override default value for SORT
2027   TAIL        Override default value for TAIL
2028   TAR         Override default value for TAR
2029   TEE         Override default value for TEE
2030   TOUCH       Override default value for TOUCH
2031   TR          Override default value for TR
2032   UNAME       Override default value for UNAME
2033   UNIQ        Override default value for UNIQ
2034   WC          Override default value for WC
2035   WHICH       Override default value for WHICH
2036   XARGS       Override default value for XARGS
2037   AWK         Override default value for AWK
2038   GREP        Override default value for GREP
2039   EGREP       Override default value for EGREP
2040   FGREP       Override default value for FGREP
2041   SED         Override default value for SED
2042   CYGPATH     Override default value for CYGPATH
2043   READLINK    Override default value for READLINK
2044   DF          Override default value for DF
2045   SETFILE     Override default value for SETFILE
2046   CPIO        Override default value for CPIO
2047   UNZIP       Override default value for UNZIP
2048   ZIP         Override default value for ZIP
2049   LDD         Override default value for LDD
2050   OTOOL       Override default value for OTOOL
2051   READELF     Override default value for READELF
2052   HG          Override default value for HG
2053   STAT        Override default value for STAT
2054   TIME        Override default value for TIME
2055   DSYMUTIL    Override default value for DSYMUTIL
2056   XATTR       Override default value for XATTR
2057   CODESIGN    Override default value for CODESIGN
2058   PKG_CONFIG  path to pkg-config utility
2059   JAVA        Override default value for JAVA
2060   JAVAC       Override default value for JAVAC
2061   JAVAH       Override default value for JAVAH
2062   JAR         Override default value for JAR
2063   NATIVE2ASCII
2064               Override default value for NATIVE2ASCII
2065   JARSIGNER   Override default value for JARSIGNER
2066   CC          C compiler command
2067   CFLAGS      C compiler flags
2068   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
2069               nonstandard directory <lib dir>
2070   LIBS        libraries to pass to the linker, e.g. -l<library>
2071   CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
2072               you have headers in a nonstandard directory <include dir>
2073   CXX         C++ compiler command
2074   CXXFLAGS    C++ compiler flags
2075   CPP         C preprocessor
2076   CXXCPP      C++ preprocessor
2077   AS          Override default value for AS
2078   AR          Override default value for AR
2079   LIPO        Override default value for LIPO
2080   STRIP       Override default value for STRIP
2081   NM          Override default value for NM
2082   GNM         Override default value for GNM
2083   MCS         Override default value for MCS
2084   OBJCOPY     Override default value for OBJCOPY
2085   OBJDUMP     Override default value for OBJDUMP
2086   BUILD_CC    Override default value for BUILD_CC
2087   BUILD_CXX   Override default value for BUILD_CXX
2088   BUILD_LD    Override default value for BUILD_LD
2089   JTREGEXE    Override default value for JTREGEXE
2090   XMKMF       Path to xmkmf, Makefile generator for X Window System
2091   FREETYPE_CFLAGS
2092               C compiler flags for FREETYPE, overriding pkg-config
2093   FREETYPE_LIBS
2094               linker flags for FREETYPE, overriding pkg-config
2095   ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
2096   ALSA_LIBS   linker flags for ALSA, overriding pkg-config
2097   LCMS_CFLAGS C compiler flags for LCMS, overriding pkg-config
2098   LCMS_LIBS   linker flags for LCMS, overriding pkg-config
2099   PNG_CFLAGS  C compiler flags for PNG, overriding pkg-config
2100   PNG_LIBS    linker flags for PNG, overriding pkg-config
2101   LIBFFI_CFLAGS
2102               C compiler flags for LIBFFI, overriding pkg-config
2103   LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
2104   CCACHE      Override default value for CCACHE
2105 
2106 Use these variables to override the choices made by `configure' or to help
2107 it to find libraries and programs with nonstandard names/locations.
2108 
2109 Report bugs to <build-dev@openjdk.java.net>.
2110 OpenJDK home page: <http://openjdk.java.net>.
2111 _ACEOF
2112 ac_status=$?
2113 fi
2114 
2115 if test "$ac_init_help" = "recursive"; then
2116   # If there are subdirs, report their specific --help.
2117   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
2118     test -d "$ac_dir" ||
2119       { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
2120       continue
2121     ac_builddir=.
2122 
2123 case "$ac_dir" in
2124 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
2125 *)
2126   ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
2127   # A ".." for each directory in $ac_dir_suffix.
2128   ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
2129   case $ac_top_builddir_sub in
2130   "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
2131   *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
2132   esac ;;
2133 esac
2134 ac_abs_top_builddir=$ac_pwd
2135 ac_abs_builddir=$ac_pwd$ac_dir_suffix
2136 # for backward compatibility:
2137 ac_top_builddir=$ac_top_build_prefix
2138 
2139 case $srcdir in
2140   .)  # We are building in place.
2141     ac_srcdir=.
2142     ac_top_srcdir=$ac_top_builddir_sub
2143     ac_abs_top_srcdir=$ac_pwd ;;
2144   [\\/]* | ?:[\\/]* )  # Absolute name.
2145     ac_srcdir=$srcdir$ac_dir_suffix;
2146     ac_top_srcdir=$srcdir
2147     ac_abs_top_srcdir=$srcdir ;;
2148   *) # Relative name.
2149     ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
2150     ac_top_srcdir=$ac_top_build_prefix$srcdir
2151     ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
2152 esac
2153 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
2154 
2155     cd "$ac_dir" || { ac_status=$?; continue; }
2156     # Check for guested configure.
2157     if test -f "$ac_srcdir/configure.gnu"; then
2158       echo &&
2159       $SHELL "$ac_srcdir/configure.gnu" --help=recursive
2160     elif test -f "$ac_srcdir/configure"; then
2161       echo &&
2162       $SHELL "$ac_srcdir/configure" --help=recursive
2163     else
2164       $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
2165     fi || ac_status=$?
2166     cd "$ac_pwd" || { ac_status=$?; break; }
2167   done
2168 fi
2169 
2170 test -n "$ac_init_help" && exit $ac_status
2171 if $ac_init_version; then
2172   cat <<\_ACEOF
2173 OpenJDK configure jdk9
2174 generated by GNU Autoconf 2.69
2175 
2176 Copyright (C) 2012 Free Software Foundation, Inc.
2177 This configure script is free software; the Free Software Foundation
2178 gives unlimited permission to copy, distribute and modify it.
2179 _ACEOF
2180   exit
2181 fi
2182 
2183 ## ------------------------ ##
2184 ## Autoconf initialization. ##
2185 ## ------------------------ ##
2186 
2187 # ac_fn_c_try_compile LINENO
2188 # --------------------------
2189 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2190 ac_fn_c_try_compile ()
2191 {
2192   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2193   rm -f conftest.$ac_objext
2194   if { { ac_try="$ac_compile"
2195 case "(($ac_try" in
2196   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2197   *) ac_try_echo=$ac_try;;
2198 esac
2199 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2200 $as_echo "$ac_try_echo"; } >&5
2201   (eval "$ac_compile") 2>conftest.err
2202   ac_status=$?
2203   if test -s conftest.err; then
2204     grep -v '^ *+' conftest.err >conftest.er1
2205     cat conftest.er1 >&5
2206     mv -f conftest.er1 conftest.err
2207   fi
2208   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2209   test $ac_status = 0; } && {
2210          test -z "$ac_c_werror_flag" ||
2211          test ! -s conftest.err
2212        } && test -s conftest.$ac_objext; then :
2213   ac_retval=0
2214 else
2215   $as_echo "$as_me: failed program was:" >&5
2216 sed 's/^/| /' conftest.$ac_ext >&5
2217 
2218         ac_retval=1
2219 fi
2220   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2221   as_fn_set_status $ac_retval
2222 
2223 } # ac_fn_c_try_compile
2224 
2225 # ac_fn_cxx_try_compile LINENO
2226 # ----------------------------
2227 # Try to compile conftest.$ac_ext, and return whether this succeeded.
2228 ac_fn_cxx_try_compile ()
2229 {
2230   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2231   rm -f conftest.$ac_objext
2232   if { { ac_try="$ac_compile"
2233 case "(($ac_try" in
2234   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2235   *) ac_try_echo=$ac_try;;
2236 esac
2237 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2238 $as_echo "$ac_try_echo"; } >&5
2239   (eval "$ac_compile") 2>conftest.err
2240   ac_status=$?
2241   if test -s conftest.err; then
2242     grep -v '^ *+' conftest.err >conftest.er1
2243     cat conftest.er1 >&5
2244     mv -f conftest.er1 conftest.err
2245   fi
2246   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2247   test $ac_status = 0; } && {
2248          test -z "$ac_cxx_werror_flag" ||
2249          test ! -s conftest.err
2250        } && test -s conftest.$ac_objext; then :
2251   ac_retval=0
2252 else
2253   $as_echo "$as_me: failed program was:" >&5
2254 sed 's/^/| /' conftest.$ac_ext >&5
2255 
2256         ac_retval=1
2257 fi
2258   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2259   as_fn_set_status $ac_retval
2260 
2261 } # ac_fn_cxx_try_compile
2262 
2263 # ac_fn_c_try_cpp LINENO
2264 # ----------------------
2265 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2266 ac_fn_c_try_cpp ()
2267 {
2268   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2269   if { { ac_try="$ac_cpp conftest.$ac_ext"
2270 case "(($ac_try" in
2271   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2272   *) ac_try_echo=$ac_try;;
2273 esac
2274 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2275 $as_echo "$ac_try_echo"; } >&5
2276   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2277   ac_status=$?
2278   if test -s conftest.err; then
2279     grep -v '^ *+' conftest.err >conftest.er1
2280     cat conftest.er1 >&5
2281     mv -f conftest.er1 conftest.err
2282   fi
2283   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2284   test $ac_status = 0; } > conftest.i && {
2285          test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
2286          test ! -s conftest.err
2287        }; then :
2288   ac_retval=0
2289 else
2290   $as_echo "$as_me: failed program was:" >&5
2291 sed 's/^/| /' conftest.$ac_ext >&5
2292 
2293     ac_retval=1
2294 fi
2295   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2296   as_fn_set_status $ac_retval
2297 
2298 } # ac_fn_c_try_cpp
2299 
2300 # ac_fn_cxx_try_cpp LINENO
2301 # ------------------------
2302 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2303 ac_fn_cxx_try_cpp ()
2304 {
2305   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2306   if { { ac_try="$ac_cpp conftest.$ac_ext"
2307 case "(($ac_try" in
2308   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2309   *) ac_try_echo=$ac_try;;
2310 esac
2311 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2312 $as_echo "$ac_try_echo"; } >&5
2313   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2314   ac_status=$?
2315   if test -s conftest.err; then
2316     grep -v '^ *+' conftest.err >conftest.er1
2317     cat conftest.er1 >&5
2318     mv -f conftest.er1 conftest.err
2319   fi
2320   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2321   test $ac_status = 0; } > conftest.i && {
2322          test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2323          test ! -s conftest.err
2324        }; then :
2325   ac_retval=0
2326 else
2327   $as_echo "$as_me: failed program was:" >&5
2328 sed 's/^/| /' conftest.$ac_ext >&5
2329 
2330     ac_retval=1
2331 fi
2332   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2333   as_fn_set_status $ac_retval
2334 
2335 } # ac_fn_cxx_try_cpp
2336 
2337 # ac_fn_c_try_link LINENO
2338 # -----------------------
2339 # Try to link conftest.$ac_ext, and return whether this succeeded.
2340 ac_fn_c_try_link ()
2341 {
2342   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2343   rm -f conftest.$ac_objext conftest$ac_exeext
2344   if { { ac_try="$ac_link"
2345 case "(($ac_try" in
2346   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2347   *) ac_try_echo=$ac_try;;
2348 esac
2349 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2350 $as_echo "$ac_try_echo"; } >&5
2351   (eval "$ac_link") 2>conftest.err
2352   ac_status=$?
2353   if test -s conftest.err; then
2354     grep -v '^ *+' conftest.err >conftest.er1
2355     cat conftest.er1 >&5
2356     mv -f conftest.er1 conftest.err
2357   fi
2358   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2359   test $ac_status = 0; } && {
2360          test -z "$ac_c_werror_flag" ||
2361          test ! -s conftest.err
2362        } && test -s conftest$ac_exeext && {
2363          test "$cross_compiling" = yes ||
2364          test -x conftest$ac_exeext
2365        }; then :
2366   ac_retval=0
2367 else
2368   $as_echo "$as_me: failed program was:" >&5
2369 sed 's/^/| /' conftest.$ac_ext >&5
2370 
2371         ac_retval=1
2372 fi
2373   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2374   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2375   # interfere with the next link command; also delete a directory that is
2376   # left behind by Apple's compiler.  We do this before executing the actions.
2377   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2378   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2379   as_fn_set_status $ac_retval
2380 
2381 } # ac_fn_c_try_link
2382 
2383 # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2384 # ---------------------------------------------------------
2385 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2386 # the include files in INCLUDES and setting the cache variable VAR
2387 # accordingly.
2388 ac_fn_cxx_check_header_mongrel ()
2389 {
2390   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2391   if eval \${$3+:} false; then :
2392   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2393 $as_echo_n "checking for $2... " >&6; }
2394 if eval \${$3+:} false; then :
2395   $as_echo_n "(cached) " >&6
2396 fi
2397 eval ac_res=\$$3
2398                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2399 $as_echo "$ac_res" >&6; }
2400 else
2401   # Is the header compilable?
2402 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2403 $as_echo_n "checking $2 usability... " >&6; }
2404 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2405 /* end confdefs.h.  */
2406 $4
2407 #include <$2>
2408 _ACEOF
2409 if ac_fn_cxx_try_compile "$LINENO"; then :
2410   ac_header_compiler=yes
2411 else
2412   ac_header_compiler=no
2413 fi
2414 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2415 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2416 $as_echo "$ac_header_compiler" >&6; }
2417 
2418 # Is the header present?
2419 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2420 $as_echo_n "checking $2 presence... " >&6; }
2421 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2422 /* end confdefs.h.  */
2423 #include <$2>
2424 _ACEOF
2425 if ac_fn_cxx_try_cpp "$LINENO"; then :
2426   ac_header_preproc=yes
2427 else
2428   ac_header_preproc=no
2429 fi
2430 rm -f conftest.err conftest.i conftest.$ac_ext
2431 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2432 $as_echo "$ac_header_preproc" >&6; }
2433 
2434 # So?  What about this header?
2435 case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2436   yes:no: )
2437     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2438 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2439     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2440 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2441     ;;
2442   no:yes:* )
2443     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2444 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2445     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
2446 $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
2447     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2448 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2449     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
2450 $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
2451     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2452 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2453 ( $as_echo "## ----------------------------------------- ##
2454 ## Report this to build-dev@openjdk.java.net ##
2455 ## ----------------------------------------- ##"
2456      ) | sed "s/^/$as_me: WARNING:     /" >&2
2457     ;;
2458 esac
2459   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2460 $as_echo_n "checking for $2... " >&6; }
2461 if eval \${$3+:} false; then :
2462   $as_echo_n "(cached) " >&6
2463 else
2464   eval "$3=\$ac_header_compiler"
2465 fi
2466 eval ac_res=\$$3
2467                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2468 $as_echo "$ac_res" >&6; }
2469 fi
2470   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2471 
2472 } # ac_fn_cxx_check_header_mongrel
2473 
2474 # ac_fn_cxx_try_run LINENO
2475 # ------------------------
2476 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2477 # that executables *can* be run.
2478 ac_fn_cxx_try_run ()
2479 {
2480   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2481   if { { ac_try="$ac_link"
2482 case "(($ac_try" in
2483   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2484   *) ac_try_echo=$ac_try;;
2485 esac
2486 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2487 $as_echo "$ac_try_echo"; } >&5
2488   (eval "$ac_link") 2>&5
2489   ac_status=$?
2490   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2491   test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2492   { { case "(($ac_try" in
2493   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2494   *) ac_try_echo=$ac_try;;
2495 esac
2496 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2497 $as_echo "$ac_try_echo"; } >&5
2498   (eval "$ac_try") 2>&5
2499   ac_status=$?
2500   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2501   test $ac_status = 0; }; }; then :
2502   ac_retval=0
2503 else
2504   $as_echo "$as_me: program exited with status $ac_status" >&5
2505        $as_echo "$as_me: failed program was:" >&5
2506 sed 's/^/| /' conftest.$ac_ext >&5
2507 
2508        ac_retval=$ac_status
2509 fi
2510   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2511   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2512   as_fn_set_status $ac_retval
2513 
2514 } # ac_fn_cxx_try_run
2515 
2516 # ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
2517 # ---------------------------------------------------------
2518 # Tests whether HEADER exists and can be compiled using the include files in
2519 # INCLUDES, setting the cache variable VAR accordingly.
2520 ac_fn_cxx_check_header_compile ()
2521 {
2522   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2523   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2524 $as_echo_n "checking for $2... " >&6; }
2525 if eval \${$3+:} false; then :
2526   $as_echo_n "(cached) " >&6
2527 else
2528   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2529 /* end confdefs.h.  */
2530 $4
2531 #include <$2>
2532 _ACEOF
2533 if ac_fn_cxx_try_compile "$LINENO"; then :
2534   eval "$3=yes"
2535 else
2536   eval "$3=no"
2537 fi
2538 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2539 fi
2540 eval ac_res=\$$3
2541                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2542 $as_echo "$ac_res" >&6; }
2543   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2544 
2545 } # ac_fn_cxx_check_header_compile
2546 
2547 # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
2548 # ----------------------------------------------
2549 # Tries to find the compile-time value of EXPR in a program that includes
2550 # INCLUDES, setting VAR accordingly. Returns whether the value could be
2551 # computed
2552 ac_fn_cxx_compute_int ()
2553 {
2554   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2555   if test "$cross_compiling" = yes; then
2556     # Depending upon the size, compute the lo and hi bounds.
2557 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2558 /* end confdefs.h.  */
2559 $4
2560 int
2561 main ()
2562 {
2563 static int test_array [1 - 2 * !(($2) >= 0)];
2564 test_array [0] = 0;
2565 return test_array [0];
2566 
2567   ;
2568   return 0;
2569 }
2570 _ACEOF
2571 if ac_fn_cxx_try_compile "$LINENO"; then :
2572   ac_lo=0 ac_mid=0
2573   while :; do
2574     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2575 /* end confdefs.h.  */
2576 $4
2577 int
2578 main ()
2579 {
2580 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2581 test_array [0] = 0;
2582 return test_array [0];
2583 
2584   ;
2585   return 0;
2586 }
2587 _ACEOF
2588 if ac_fn_cxx_try_compile "$LINENO"; then :
2589   ac_hi=$ac_mid; break
2590 else
2591   as_fn_arith $ac_mid + 1 && ac_lo=$as_val
2592                         if test $ac_lo -le $ac_mid; then
2593                           ac_lo= ac_hi=
2594                           break
2595                         fi
2596                         as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
2597 fi
2598 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2599   done
2600 else
2601   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2602 /* end confdefs.h.  */
2603 $4
2604 int
2605 main ()
2606 {
2607 static int test_array [1 - 2 * !(($2) < 0)];
2608 test_array [0] = 0;
2609 return test_array [0];
2610 
2611   ;
2612   return 0;
2613 }
2614 _ACEOF
2615 if ac_fn_cxx_try_compile "$LINENO"; then :
2616   ac_hi=-1 ac_mid=-1
2617   while :; do
2618     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2619 /* end confdefs.h.  */
2620 $4
2621 int
2622 main ()
2623 {
2624 static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2625 test_array [0] = 0;
2626 return test_array [0];
2627 
2628   ;
2629   return 0;
2630 }
2631 _ACEOF
2632 if ac_fn_cxx_try_compile "$LINENO"; then :
2633   ac_lo=$ac_mid; break
2634 else
2635   as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2636                         if test $ac_mid -le $ac_hi; then
2637                           ac_lo= ac_hi=
2638                           break
2639                         fi
2640                         as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2641 fi
2642 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2643   done
2644 else
2645   ac_lo= ac_hi=
2646 fi
2647 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2648 fi
2649 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2650 # Binary search between lo and hi bounds.
2651 while test "x$ac_lo" != "x$ac_hi"; do
2652   as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2653   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2654 /* end confdefs.h.  */
2655 $4
2656 int
2657 main ()
2658 {
2659 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2660 test_array [0] = 0;
2661 return test_array [0];
2662 
2663   ;
2664   return 0;
2665 }
2666 _ACEOF
2667 if ac_fn_cxx_try_compile "$LINENO"; then :
2668   ac_hi=$ac_mid
2669 else
2670   as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2671 fi
2672 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2673 done
2674 case $ac_lo in #((
2675 ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2676 '') ac_retval=1 ;;
2677 esac
2678   else
2679     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2680 /* end confdefs.h.  */
2681 $4
2682 static long int longval () { return $2; }
2683 static unsigned long int ulongval () { return $2; }
2684 #include <stdio.h>
2685 #include <stdlib.h>
2686 int
2687 main ()
2688 {
2689 
2690   FILE *f = fopen ("conftest.val", "w");
2691   if (! f)
2692     return 1;
2693   if (($2) < 0)
2694     {
2695       long int i = longval ();
2696       if (i != ($2))
2697         return 1;
2698       fprintf (f, "%ld", i);
2699     }
2700   else
2701     {
2702       unsigned long int i = ulongval ();
2703       if (i != ($2))
2704         return 1;
2705       fprintf (f, "%lu", i);
2706     }
2707   /* Do not output a trailing newline, as this causes \r\n confusion
2708      on some platforms.  */
2709   return ferror (f) || fclose (f) != 0;
2710 
2711   ;
2712   return 0;
2713 }
2714 _ACEOF
2715 if ac_fn_cxx_try_run "$LINENO"; then :
2716   echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2717 else
2718   ac_retval=1
2719 fi
2720 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2721   conftest.$ac_objext conftest.beam conftest.$ac_ext
2722 rm -f conftest.val
2723 
2724   fi
2725   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2726   as_fn_set_status $ac_retval
2727 
2728 } # ac_fn_cxx_compute_int
2729 
2730 # ac_fn_cxx_try_link LINENO
2731 # -------------------------
2732 # Try to link conftest.$ac_ext, and return whether this succeeded.
2733 ac_fn_cxx_try_link ()
2734 {
2735   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2736   rm -f conftest.$ac_objext conftest$ac_exeext
2737   if { { ac_try="$ac_link"
2738 case "(($ac_try" in
2739   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2740   *) ac_try_echo=$ac_try;;
2741 esac
2742 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2743 $as_echo "$ac_try_echo"; } >&5
2744   (eval "$ac_link") 2>conftest.err
2745   ac_status=$?
2746   if test -s conftest.err; then
2747     grep -v '^ *+' conftest.err >conftest.er1
2748     cat conftest.er1 >&5
2749     mv -f conftest.er1 conftest.err
2750   fi
2751   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2752   test $ac_status = 0; } && {
2753          test -z "$ac_cxx_werror_flag" ||
2754          test ! -s conftest.err
2755        } && test -s conftest$ac_exeext && {
2756          test "$cross_compiling" = yes ||
2757          test -x conftest$ac_exeext
2758        }; then :
2759   ac_retval=0
2760 else
2761   $as_echo "$as_me: failed program was:" >&5
2762 sed 's/^/| /' conftest.$ac_ext >&5
2763 
2764         ac_retval=1
2765 fi
2766   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
2767   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
2768   # interfere with the next link command; also delete a directory that is
2769   # left behind by Apple's compiler.  We do this before executing the actions.
2770   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2771   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2772   as_fn_set_status $ac_retval
2773 
2774 } # ac_fn_cxx_try_link
2775 
2776 # ac_fn_cxx_check_func LINENO FUNC VAR
2777 # ------------------------------------
2778 # Tests whether FUNC exists, setting the cache variable VAR accordingly
2779 ac_fn_cxx_check_func ()
2780 {
2781   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2782   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2783 $as_echo_n "checking for $2... " >&6; }
2784 if eval \${$3+:} false; then :
2785   $as_echo_n "(cached) " >&6
2786 else
2787   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2788 /* end confdefs.h.  */
2789 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
2790    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
2791 #define $2 innocuous_$2
2792 
2793 /* System header to define __stub macros and hopefully few prototypes,
2794     which can conflict with char $2 (); below.
2795     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2796     <limits.h> exists even on freestanding compilers.  */
2797 
2798 #ifdef __STDC__
2799 # include <limits.h>
2800 #else
2801 # include <assert.h>
2802 #endif
2803 
2804 #undef $2
2805 
2806 /* Override any GCC internal prototype to avoid an error.
2807    Use char because int might match the return type of a GCC
2808    builtin and then its argument prototype would still apply.  */
2809 #ifdef __cplusplus
2810 extern "C"
2811 #endif
2812 char $2 ();
2813 /* The GNU C library defines this for functions which it implements
2814     to always fail with ENOSYS.  Some functions are actually named
2815     something starting with __ and the normal name is an alias.  */
2816 #if defined __stub_$2 || defined __stub___$2
2817 choke me
2818 #endif
2819 
2820 int
2821 main ()
2822 {
2823 return $2 ();
2824   ;
2825   return 0;
2826 }
2827 _ACEOF
2828 if ac_fn_cxx_try_link "$LINENO"; then :
2829   eval "$3=yes"
2830 else
2831   eval "$3=no"
2832 fi
2833 rm -f core conftest.err conftest.$ac_objext \
2834     conftest$ac_exeext conftest.$ac_ext
2835 fi
2836 eval ac_res=\$$3
2837                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2838 $as_echo "$ac_res" >&6; }
2839   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2840 
2841 } # ac_fn_cxx_check_func
2842 
2843 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
2844 # -------------------------------------------------------
2845 # Tests whether HEADER exists and can be compiled using the include files in
2846 # INCLUDES, setting the cache variable VAR accordingly.
2847 ac_fn_c_check_header_compile ()
2848 {
2849   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2850   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2851 $as_echo_n "checking for $2... " >&6; }
2852 if eval \${$3+:} false; then :
2853   $as_echo_n "(cached) " >&6
2854 else
2855   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2856 /* end confdefs.h.  */
2857 $4
2858 #include <$2>
2859 _ACEOF
2860 if ac_fn_c_try_compile "$LINENO"; then :
2861   eval "$3=yes"
2862 else
2863   eval "$3=no"
2864 fi
2865 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2866 fi
2867 eval ac_res=\$$3
2868                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2869 $as_echo "$ac_res" >&6; }
2870   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2871 
2872 } # ac_fn_c_check_header_compile
2873 cat >config.log <<_ACEOF
2874 This file contains any messages produced by compilers while
2875 running configure, to aid debugging if configure makes a mistake.
2876 
2877 It was created by OpenJDK $as_me jdk9, which was
2878 generated by GNU Autoconf 2.69.  Invocation command line was
2879 
2880   $ $0 $@
2881 
2882 _ACEOF
2883 exec 5>>config.log
2884 {
2885 cat <<_ASUNAME
2886 ## --------- ##
2887 ## Platform. ##
2888 ## --------- ##
2889 
2890 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
2891 uname -m = `(uname -m) 2>/dev/null || echo unknown`
2892 uname -r = `(uname -r) 2>/dev/null || echo unknown`
2893 uname -s = `(uname -s) 2>/dev/null || echo unknown`
2894 uname -v = `(uname -v) 2>/dev/null || echo unknown`
2895 
2896 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
2897 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
2898 
2899 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
2900 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
2901 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
2902 /usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
2903 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
2904 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
2905 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
2906 
2907 _ASUNAME
2908 
2909 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2910 for as_dir in $PATH
2911 do
2912   IFS=$as_save_IFS
2913   test -z "$as_dir" && as_dir=.
2914     $as_echo "PATH: $as_dir"
2915   done
2916 IFS=$as_save_IFS
2917 
2918 } >&5
2919 
2920 cat >&5 <<_ACEOF
2921 
2922 
2923 ## ----------- ##
2924 ## Core tests. ##
2925 ## ----------- ##
2926 
2927 _ACEOF
2928 
2929 
2930 # Keep a trace of the command line.
2931 # Strip out --no-create and --no-recursion so they do not pile up.
2932 # Strip out --silent because we don't want to record it for future runs.
2933 # Also quote any args containing shell meta-characters.
2934 # Make two passes to allow for proper duplicate-argument suppression.
2935 ac_configure_args=
2936 ac_configure_args0=
2937 ac_configure_args1=
2938 ac_must_keep_next=false
2939 for ac_pass in 1 2
2940 do
2941   for ac_arg
2942   do
2943     case $ac_arg in
2944     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
2945     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
2946     | -silent | --silent | --silen | --sile | --sil)
2947       continue ;;
2948     *\'*)
2949       ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
2950     esac
2951     case $ac_pass in
2952     1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2953     2)
2954       as_fn_append ac_configure_args1 " '$ac_arg'"
2955       if test $ac_must_keep_next = true; then
2956         ac_must_keep_next=false # Got value, back to normal.
2957       else
2958         case $ac_arg in
2959           *=* | --config-cache | -C | -disable-* | --disable-* \
2960           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
2961           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
2962           | -with-* | --with-* | -without-* | --without-* | --x)
2963             case "$ac_configure_args0 " in
2964               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
2965             esac
2966             ;;
2967           -* ) ac_must_keep_next=true ;;
2968         esac
2969       fi
2970       as_fn_append ac_configure_args " '$ac_arg'"
2971       ;;
2972     esac
2973   done
2974 done
2975 { ac_configure_args0=; unset ac_configure_args0;}
2976 { ac_configure_args1=; unset ac_configure_args1;}
2977 
2978 # When interrupted or exit'd, cleanup temporary files, and complete
2979 # config.log.  We remove comments because anyway the quotes in there
2980 # would cause problems or look ugly.
2981 # WARNING: Use '\'' to represent an apostrophe within the trap.
2982 # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
2983 trap 'exit_status=$?
2984   # Save into config.log some information that might help in debugging.
2985   {
2986     echo
2987 
2988     $as_echo "## ---------------- ##
2989 ## Cache variables. ##
2990 ## ---------------- ##"
2991     echo
2992     # The following way of writing the cache mishandles newlines in values,
2993 (
2994   for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
2995     eval ac_val=\$$ac_var
2996     case $ac_val in #(
2997     *${as_nl}*)
2998       case $ac_var in #(
2999       *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
3000 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
3001       esac
3002       case $ac_var in #(
3003       _ | IFS | as_nl) ;; #(
3004       BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
3005       *) { eval $ac_var=; unset $ac_var;} ;;
3006       esac ;;
3007     esac
3008   done
3009   (set) 2>&1 |
3010     case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
3011     *${as_nl}ac_space=\ *)
3012       sed -n \
3013         "s/'\''/'\''\\\\'\'''\''/g;
3014           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
3015       ;; #(
3016     *)
3017       sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
3018       ;;
3019     esac |
3020     sort
3021 )
3022     echo
3023 
3024     $as_echo "## ----------------- ##
3025 ## Output variables. ##
3026 ## ----------------- ##"
3027     echo
3028     for ac_var in $ac_subst_vars
3029     do
3030       eval ac_val=\$$ac_var
3031       case $ac_val in
3032       *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3033       esac
3034       $as_echo "$ac_var='\''$ac_val'\''"
3035     done | sort
3036     echo
3037 
3038     if test -n "$ac_subst_files"; then
3039       $as_echo "## ------------------- ##
3040 ## File substitutions. ##
3041 ## ------------------- ##"
3042       echo
3043       for ac_var in $ac_subst_files
3044       do
3045         eval ac_val=\$$ac_var
3046         case $ac_val in
3047         *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
3048         esac
3049         $as_echo "$ac_var='\''$ac_val'\''"
3050       done | sort
3051       echo
3052     fi
3053 
3054     if test -s confdefs.h; then
3055       $as_echo "## ----------- ##
3056 ## confdefs.h. ##
3057 ## ----------- ##"
3058       echo
3059       cat confdefs.h
3060       echo
3061     fi
3062     test "$ac_signal" != 0 &&
3063       $as_echo "$as_me: caught signal $ac_signal"
3064     $as_echo "$as_me: exit $exit_status"
3065   } >&5
3066   rm -f core *.core core.conftest.* &&
3067     rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
3068     exit $exit_status
3069 ' 0
3070 for ac_signal in 1 2 13 15; do
3071   trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
3072 done
3073 ac_signal=0
3074 
3075 # confdefs.h avoids OS command line length limits that DEFS can exceed.
3076 rm -f -r conftest* confdefs.h
3077 
3078 $as_echo "/* confdefs.h */" > confdefs.h
3079 
3080 # Predefined preprocessor variables.
3081 
3082 cat >>confdefs.h <<_ACEOF
3083 #define PACKAGE_NAME "$PACKAGE_NAME"
3084 _ACEOF
3085 
3086 cat >>confdefs.h <<_ACEOF
3087 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
3088 _ACEOF
3089 
3090 cat >>confdefs.h <<_ACEOF
3091 #define PACKAGE_VERSION "$PACKAGE_VERSION"
3092 _ACEOF
3093 
3094 cat >>confdefs.h <<_ACEOF
3095 #define PACKAGE_STRING "$PACKAGE_STRING"
3096 _ACEOF
3097 
3098 cat >>confdefs.h <<_ACEOF
3099 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
3100 _ACEOF
3101 
3102 cat >>confdefs.h <<_ACEOF
3103 #define PACKAGE_URL "$PACKAGE_URL"
3104 _ACEOF
3105 
3106 
3107 # Let the site file select an alternate cache file if it wants to.
3108 # Prefer an explicitly selected file to automatically selected ones.
3109 ac_site_file1=NONE
3110 ac_site_file2=NONE
3111 if test -n "$CONFIG_SITE"; then
3112   # We do not want a PATH search for config.site.
3113   case $CONFIG_SITE in #((
3114     -*)  ac_site_file1=./$CONFIG_SITE;;
3115     */*) ac_site_file1=$CONFIG_SITE;;
3116     *)   ac_site_file1=./$CONFIG_SITE;;
3117   esac
3118 elif test "x$prefix" != xNONE; then
3119   ac_site_file1=$prefix/share/config.site
3120   ac_site_file2=$prefix/etc/config.site
3121 else
3122   ac_site_file1=$ac_default_prefix/share/config.site
3123   ac_site_file2=$ac_default_prefix/etc/config.site
3124 fi
3125 for ac_site_file in "$ac_site_file1" "$ac_site_file2"
3126 do
3127   test "x$ac_site_file" = xNONE && continue
3128   if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
3129     { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
3130 $as_echo "$as_me: loading site script $ac_site_file" >&6;}
3131     sed 's/^/| /' "$ac_site_file" >&5
3132     . "$ac_site_file" \
3133       || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3134 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3135 as_fn_error $? "failed to load site script $ac_site_file
3136 See \`config.log' for more details" "$LINENO" 5; }
3137   fi
3138 done
3139 
3140 if test -r "$cache_file"; then
3141   # Some versions of bash will fail to source /dev/null (special files
3142   # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
3143   if test /dev/null != "$cache_file" && test -f "$cache_file"; then
3144     { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
3145 $as_echo "$as_me: loading cache $cache_file" >&6;}
3146     case $cache_file in
3147       [\\/]* | ?:[\\/]* ) . "$cache_file";;
3148       *)                      . "./$cache_file";;
3149     esac
3150   fi
3151 else
3152   { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
3153 $as_echo "$as_me: creating cache $cache_file" >&6;}
3154   >$cache_file
3155 fi
3156 
3157 # Check that the precious variables saved in the cache have kept the same
3158 # value.
3159 ac_cache_corrupted=false
3160 for ac_var in $ac_precious_vars; do
3161   eval ac_old_set=\$ac_cv_env_${ac_var}_set
3162   eval ac_new_set=\$ac_env_${ac_var}_set
3163   eval ac_old_val=\$ac_cv_env_${ac_var}_value
3164   eval ac_new_val=\$ac_env_${ac_var}_value
3165   case $ac_old_set,$ac_new_set in
3166     set,)
3167       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
3168 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
3169       ac_cache_corrupted=: ;;
3170     ,set)
3171       { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
3172 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
3173       ac_cache_corrupted=: ;;
3174     ,);;
3175     *)
3176       if test "x$ac_old_val" != "x$ac_new_val"; then
3177         # differences in whitespace do not lead to failure.
3178         ac_old_val_w=`echo x $ac_old_val`
3179         ac_new_val_w=`echo x $ac_new_val`
3180         if test "$ac_old_val_w" != "$ac_new_val_w"; then
3181           { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
3182 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
3183           ac_cache_corrupted=:
3184         else
3185           { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
3186 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
3187           eval $ac_var=\$ac_old_val
3188         fi
3189         { $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
3190 $as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
3191         { $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
3192 $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
3193       fi;;
3194   esac
3195   # Pass precious variables to config.status.
3196   if test "$ac_new_set" = set; then
3197     case $ac_new_val in
3198     *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
3199     *) ac_arg=$ac_var=$ac_new_val ;;
3200     esac
3201     case " $ac_configure_args " in
3202       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
3203       *) as_fn_append ac_configure_args " '$ac_arg'" ;;
3204     esac
3205   fi
3206 done
3207 if $ac_cache_corrupted; then
3208   { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3209 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3210   { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
3211 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
3212   as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
3213 fi
3214 ## -------------------- ##
3215 ## Main body of script. ##
3216 ## -------------------- ##
3217 
3218 ac_ext=c
3219 ac_cpp='$CPP $CPPFLAGS'
3220 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3221 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3222 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3223 
3224 
3225 
3226 ac_aux_dir=
3227 for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
3228   if test -f "$ac_dir/install-sh"; then
3229     ac_aux_dir=$ac_dir
3230     ac_install_sh="$ac_aux_dir/install-sh -c"
3231     break
3232   elif test -f "$ac_dir/install.sh"; then
3233     ac_aux_dir=$ac_dir
3234     ac_install_sh="$ac_aux_dir/install.sh -c"
3235     break
3236   elif test -f "$ac_dir/shtool"; then
3237     ac_aux_dir=$ac_dir
3238     ac_install_sh="$ac_aux_dir/shtool install -c"
3239     break
3240   fi
3241 done
3242 if test -z "$ac_aux_dir"; then
3243   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
3244 fi
3245 
3246 # These three variables are undocumented and unsupported,
3247 # and are intended to be withdrawn in a future Autoconf release.
3248 # They can cause serious problems if a builder's source tree is in a directory
3249 # whose full name contains unusual characters.
3250 ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
3251 ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
3252 ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
3253 
3254 
3255 # pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
3256 
3257 #
3258 # Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3259 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3260 #
3261 # This code is free software; you can redistribute it and/or modify it
3262 # under the terms of the GNU General Public License version 2 only, as
3263 # published by the Free Software Foundation.  Oracle designates this
3264 # particular file as subject to the "Classpath" exception as provided
3265 # by Oracle in the LICENSE file that accompanied this code.
3266 #
3267 # This code is distributed in the hope that it will be useful, but WITHOUT
3268 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3269 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3270 # version 2 for more details (a copy is included in the LICENSE file that
3271 # accompanied this code).
3272 #
3273 # You should have received a copy of the GNU General Public License version
3274 # 2 along with this work; if not, write to the Free Software Foundation,
3275 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3276 #
3277 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3278 # or visit www.oracle.com if you need additional information or have any
3279 # questions.
3280 #
3281 
3282 #
3283 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
3284 #
3285 # This program is free software; you can redistribute it and/or modify
3286 # it under the terms of the GNU General Public License as published by
3287 # the Free Software Foundation; either version 2 of the License, or
3288 # (at your option) any later version.
3289 #
3290 # This program is distributed in the hope that it will be useful, but
3291 # WITHOUT ANY WARRANTY; without even the implied warranty of
3292 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3293 # General Public License for more details.
3294 #
3295 # You should have received a copy of the GNU General Public License
3296 # along with this program; if not, write to the Free Software
3297 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
3298 #
3299 # As a special exception to the GNU General Public License, if you
3300 # distribute this file as part of a program that contains a
3301 # configuration script generated by Autoconf, you may include it under
3302 # the same distribution terms that you use for the rest of that program.
3303 
3304 # PKG_PROG_PKG_CONFIG([MIN-VERSION])
3305 # ----------------------------------
3306 # PKG_PROG_PKG_CONFIG
3307 
3308 # PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
3309 #
3310 # Check to see whether a particular set of modules exists.  Similar
3311 # to PKG_CHECK_MODULES(), but does not set variables or print errors.
3312 #
3313 #
3314 # Similar to PKG_CHECK_MODULES, make sure that the first instance of
3315 # this or PKG_CHECK_MODULES is called, or make sure to call
3316 # PKG_CHECK_EXISTS manually
3317 # --------------------------------------------------------------
3318 
3319 
3320 
3321 # _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
3322 # ---------------------------------------------
3323 # _PKG_CONFIG
3324 
3325 # _PKG_SHORT_ERRORS_SUPPORTED
3326 # -----------------------------
3327 # _PKG_SHORT_ERRORS_SUPPORTED
3328 
3329 
3330 # PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
3331 # [ACTION-IF-NOT-FOUND])
3332 #
3333 #
3334 # Note that if there is a possibility the first call to
3335 # PKG_CHECK_MODULES might not happen, you should be sure to include an
3336 # explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
3337 #
3338 #
3339 # --------------------------------------------------------------
3340 # PKG_CHECK_MODULES
3341 
3342 
3343 # Include these first...
3344 #
3345 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3346 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3347 #
3348 # This code is free software; you can redistribute it and/or modify it
3349 # under the terms of the GNU General Public License version 2 only, as
3350 # published by the Free Software Foundation.  Oracle designates this
3351 # particular file as subject to the "Classpath" exception as provided
3352 # by Oracle in the LICENSE file that accompanied this code.
3353 #
3354 # This code is distributed in the hope that it will be useful, but WITHOUT
3355 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3356 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3357 # version 2 for more details (a copy is included in the LICENSE file that
3358 # accompanied this code).
3359 #
3360 # You should have received a copy of the GNU General Public License version
3361 # 2 along with this work; if not, write to the Free Software Foundation,
3362 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3363 #
3364 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3365 # or visit www.oracle.com if you need additional information or have any
3366 # questions.
3367 #
3368 
3369 # Test if $1 is a valid argument to $3 (often is $JAVA passed as $3)
3370 # If so, then append $1 to $2 \
3371 # Also set JVM_ARG_OK to true/false depending on outcome.
3372 
3373 
3374 # Appends a string to a path variable, only adding the : when needed.
3375 
3376 
3377 # Prepends a string to a path variable, only adding the : when needed.
3378 
3379 
3380 # This will make sure the given variable points to a full and proper
3381 # path. This means:
3382 # 1) There will be no spaces in the path. On unix platforms,
3383 #    spaces in the path will result in an error. On Windows,
3384 #    the path will be rewritten using short-style to be space-free.
3385 # 2) The path will be absolute, and it will be in unix-style (on
3386 #     cygwin).
3387 # $1: The name of the variable to fix
3388 
3389 
3390 # This will make sure the given variable points to a executable
3391 # with a full and proper path. This means:
3392 # 1) There will be no spaces in the path. On unix platforms,
3393 #    spaces in the path will result in an error. On Windows,
3394 #    the path will be rewritten using short-style to be space-free.
3395 # 2) The path will be absolute, and it will be in unix-style (on
3396 #     cygwin).
3397 # Any arguments given to the executable is preserved.
3398 # If the input variable does not have a directory specification, then
3399 # it need to be in the PATH.
3400 # $1: The name of the variable to fix
3401 
3402 
3403 
3404 
3405 # Register a --with argument but mark it as deprecated
3406 # $1: The name of the with argument to deprecate, not including --with-
3407 
3408 
3409 # Register a --enable argument but mark it as deprecated
3410 # $1: The name of the with argument to deprecate, not including --enable-
3411 # $2: The name of the argument to deprecate, in shell variable style (i.e. with _ instead of -)
3412 
3413 
3414 
3415 
3416 # Test that variable $1 denoting a program is not empty. If empty, exit with an error.
3417 # $1: variable to check
3418 
3419 
3420 # Check that there are no unprocessed overridden variables left.
3421 # If so, they are an incorrect argument and we will exit with an error.
3422 
3423 
3424 # Setup a tool for the given variable. If correctly specified by the user,
3425 # use that value, otherwise search for the tool using the supplied code snippet.
3426 # $1: variable to set
3427 # $2: code snippet to call to look for the tool
3428 
3429 
3430 # Call BASIC_SETUP_TOOL with AC_PATH_PROGS to locate the tool
3431 # $1: variable to set
3432 # $2: executable name (or list of names) to look for
3433 
3434 
3435 # Call BASIC_SETUP_TOOL with AC_CHECK_TOOLS to locate the tool
3436 # $1: variable to set
3437 # $2: executable name (or list of names) to look for
3438 
3439 
3440 # Like BASIC_PATH_PROGS but fails if no tool was found.
3441 # $1: variable to set
3442 # $2: executable name (or list of names) to look for
3443 
3444 
3445 # Like BASIC_SETUP_TOOL but fails if no tool was found.
3446 # $1: variable to set
3447 # $2: autoconf macro to call to look for the special tool
3448 
3449 
3450 # Setup the most fundamental tools that relies on not much else to set up,
3451 # but is used by much of the early bootstrap code.
3452 
3453 
3454 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3455 
3456 
3457 
3458 
3459 
3460 
3461 
3462 
3463 
3464 #%%% Simple tools %%%
3465 
3466 # Check if we have found a usable version of make
3467 # $1: the path to a potential make binary (or empty)
3468 # $2: the description on how we found this
3469 
3470 
3471 
3472 
3473 # Goes looking for a usable version of GNU make.
3474 
3475 
3476 
3477 
3478 
3479 
3480 # Check if build directory is on local disk. If not possible to determine,
3481 # we prefer to claim it's local.
3482 # Argument 1: directory to test
3483 # Argument 2: what to do if it is on local disk
3484 # Argument 3: what to do otherwise (remote disk or failure)
3485 
3486 
3487 # Check that source files have basic read permissions set. This might
3488 # not be the case in cygwin in certain conditions.
3489 
3490 
3491 
3492 
3493 # Check for support for specific options in bash
3494 
3495 
3496 #
3497 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3498 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3499 #
3500 # This code is free software; you can redistribute it and/or modify it
3501 # under the terms of the GNU General Public License version 2 only, as
3502 # published by the Free Software Foundation.  Oracle designates this
3503 # particular file as subject to the "Classpath" exception as provided
3504 # by Oracle in the LICENSE file that accompanied this code.
3505 #
3506 # This code is distributed in the hope that it will be useful, but WITHOUT
3507 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3508 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3509 # version 2 for more details (a copy is included in the LICENSE file that
3510 # accompanied this code).
3511 #
3512 # You should have received a copy of the GNU General Public License version
3513 # 2 along with this work; if not, write to the Free Software Foundation,
3514 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3515 #
3516 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3517 # or visit www.oracle.com if you need additional information or have any
3518 # questions.
3519 #
3520 
3521 
3522 
3523 
3524 
3525 # Helper function which possibly converts a path using DOS-style short mode.
3526 # If so, the updated path is stored in $new_path.
3527 # $1: The path to check
3528 
3529 
3530 # Helper function which possibly converts a path using DOS-style short mode.
3531 # If so, the updated path is stored in $new_path.
3532 # $1: The path to check
3533 
3534 
3535 # FIXME: The BASIC_FIXUP_*_CYGWIN/MSYS is most likely too convoluted
3536 # and could probably be heavily simplified. However, all changes in this
3537 # area tend to need lot of testing in different scenarios, and in lack of
3538 # proper unit testing, cleaning this up has not been deemed worth the effort
3539 # at the moment.
3540 
3541 
3542 
3543 
3544 
3545 
3546 
3547 
3548 
3549 # Setup basic configuration paths, and platform-specific stuff related to PATHs.
3550 
3551 
3552 
3553 
3554 #
3555 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3556 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3557 #
3558 # This code is free software; you can redistribute it and/or modify it
3559 # under the terms of the GNU General Public License version 2 only, as
3560 # published by the Free Software Foundation.  Oracle designates this
3561 # particular file as subject to the "Classpath" exception as provided
3562 # by Oracle in the LICENSE file that accompanied this code.
3563 #
3564 # This code is distributed in the hope that it will be useful, but WITHOUT
3565 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3566 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3567 # version 2 for more details (a copy is included in the LICENSE file that
3568 # accompanied this code).
3569 #
3570 # You should have received a copy of the GNU General Public License version
3571 # 2 along with this work; if not, write to the Free Software Foundation,
3572 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3573 #
3574 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3575 # or visit www.oracle.com if you need additional information or have any
3576 # questions.
3577 #
3578 
3579 
3580 
3581 
3582 
3583 
3584 
3585 
3586 
3587 
3588 
3589 # ... then the rest
3590 #
3591 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3592 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3593 #
3594 # This code is free software; you can redistribute it and/or modify it
3595 # under the terms of the GNU General Public License version 2 only, as
3596 # published by the Free Software Foundation.  Oracle designates this
3597 # particular file as subject to the "Classpath" exception as provided
3598 # by Oracle in the LICENSE file that accompanied this code.
3599 #
3600 # This code is distributed in the hope that it will be useful, but WITHOUT
3601 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3602 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3603 # version 2 for more details (a copy is included in the LICENSE file that
3604 # accompanied this code).
3605 #
3606 # You should have received a copy of the GNU General Public License version
3607 # 2 along with this work; if not, write to the Free Software Foundation,
3608 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3609 #
3610 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3611 # or visit www.oracle.com if you need additional information or have any
3612 # questions.
3613 #
3614 
3615 ########################################################################
3616 # This file handles detection of the Boot JDK. The Boot JDK detection
3617 # process has been developed as a response to solve a complex real-world
3618 # problem. Initially, it was simple, but it has grown as platform after
3619 # platform, idiosyncracy after idiosyncracy has been supported.
3620 #
3621 # The basic idea is this:
3622 # 1) You need an acceptable *) JDK to use as a Boot JDK
3623 # 2) There are several ways to locate a JDK, that are mostly platform
3624 #    dependent **)
3625 # 3) You can have multiple JDKs installed
3626 # 4) If possible, configure should try to dig out an acceptable JDK
3627 #    automatically, without having to resort to command-line options
3628 #
3629 # *)  acceptable means e.g. JDK7 for building JDK8, a complete JDK (with
3630 #     javac) and not a JRE, etc.
3631 #
3632 # **) On Windows we typically use a well-known path.
3633 #     On MacOSX we typically use the tool java_home.
3634 #     On Linux we typically find javac in the $PATH, and then follow a
3635 #     chain of symlinks that often ends up in a real JDK.
3636 #
3637 # This leads to the code where we check in different ways to locate a
3638 # JDK, and if one is found, check if it is acceptable. If not, we print
3639 # our reasons for rejecting it (useful when debugging non-working
3640 # configure situations) and continue checking the next one.
3641 ########################################################################
3642 
3643 # Execute the check given as argument, and verify the result
3644 # If the Boot JDK was previously found, do nothing
3645 # $1 A command line (typically autoconf macro) to execute
3646 
3647 
3648 # Test: Is bootjdk explicitely set by command line arguments?
3649 
3650 
3651 # Test: Is bootjdk available from builddeps?
3652 
3653 
3654 # Test: Is $JAVA_HOME set?
3655 
3656 
3657 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
3658 
3659 
3660 # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
3661 # $1: Argument to the java_home binary (optional)
3662 
3663 
3664 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
3665 
3666 
3667 # Look for a jdk in the given path. If there are multiple, try to select the newest.
3668 # If found, set BOOT_JDK and BOOT_JDK_FOUND.
3669 # $1 = Path to directory containing jdk installations.
3670 # $2 = String to append to the found JDK directory to get the proper JDK home
3671 
3672 
3673 # Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
3674 # environmental variable as base for where to look.
3675 # $1 Name of an environmal variable, assumed to point to the Program Files directory.
3676 
3677 
3678 # Test: Is there a JDK installed in default, well-known locations?
3679 
3680 
3681 # Check that a command-line tool in the Boot JDK is correct
3682 # $1 = name of variable to assign
3683 # $2 = name of binary
3684 
3685 
3686 ###############################################################################
3687 #
3688 # We need a Boot JDK to bootstrap the build.
3689 #
3690 
3691 
3692 
3693 
3694 
3695 #
3696 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3697 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3698 #
3699 # This code is free software; you can redistribute it and/or modify it
3700 # under the terms of the GNU General Public License version 2 only, as
3701 # published by the Free Software Foundation.  Oracle designates this
3702 # particular file as subject to the "Classpath" exception as provided
3703 # by Oracle in the LICENSE file that accompanied this code.
3704 #
3705 # This code is distributed in the hope that it will be useful, but WITHOUT
3706 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3707 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3708 # version 2 for more details (a copy is included in the LICENSE file that
3709 # accompanied this code).
3710 #
3711 # You should have received a copy of the GNU General Public License version
3712 # 2 along with this work; if not, write to the Free Software Foundation,
3713 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3714 #
3715 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3716 # or visit www.oracle.com if you need additional information or have any
3717 # questions.
3718 #
3719 
3720 
3721 
3722 
3723 
3724 
3725 
3726 
3727 
3728 
3729 
3730 
3731 
3732 
3733 
3734 
3735 
3736 
3737 
3738 
3739 #
3740 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3741 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3742 #
3743 # This code is free software; you can redistribute it and/or modify it
3744 # under the terms of the GNU General Public License version 2 only, as
3745 # published by the Free Software Foundation.  Oracle designates this
3746 # particular file as subject to the "Classpath" exception as provided
3747 # by Oracle in the LICENSE file that accompanied this code.
3748 #
3749 # This code is distributed in the hope that it will be useful, but WITHOUT
3750 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3751 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3752 # version 2 for more details (a copy is included in the LICENSE file that
3753 # accompanied this code).
3754 #
3755 # You should have received a copy of the GNU General Public License version
3756 # 2 along with this work; if not, write to the Free Software Foundation,
3757 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3758 #
3759 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3760 # or visit www.oracle.com if you need additional information or have any
3761 # questions.
3762 #
3763 
3764 
3765 
3766 
3767 
3768 # Documentation on common flags used for solstudio in HIGHEST.
3769 #
3770 # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
3771 #          done with care, there are some assumptions below that need to
3772 #          be understood about the use of pointers, and IEEE behavior.
3773 #
3774 # -fns: Use non-standard floating point mode (not IEEE 754)
3775 # -fsimple: Do some simplification of floating point arithmetic (not IEEE 754)
3776 # -fsingle: Use single precision floating point with 'float'
3777 # -xalias_level=basic: Assume memory references via basic pointer types do not alias
3778 #   (Source with excessing pointer casting and data access with mixed
3779 #    pointer types are not recommended)
3780 # -xbuiltin=%all: Use intrinsic or inline versions for math/std functions
3781 #   (If you expect perfect errno behavior, do not use this)
3782 # -xdepend: Loop data dependency optimizations (need -xO3 or higher)
3783 # -xrestrict: Pointer parameters to functions do not overlap
3784 #   (Similar to -xalias_level=basic usage, but less obvious sometimes.
3785 #    If you pass in multiple pointers to the same data, do not use this)
3786 # -xlibmil: Inline some library routines
3787 #   (If you expect perfect errno behavior, do not use this)
3788 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
3789 #   (If you expect perfect errno behavior, do not use this)
3790 #  Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
3791 
3792     # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
3793     # Bug?
3794     #if test "x$OPENJDK_TARGET_CPU" = xsparc; then
3795     #  CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
3796     #  CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
3797     #fi
3798 
3799 
3800 
3801 
3802 
3803 # FLAGS_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3804 #                                   [RUN-IF-FALSE])
3805 # ------------------------------------------------------------
3806 # Check that the c and c++ compilers support an argument
3807 
3808 
3809 # FLAGS_LINKER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
3810 #                                    [RUN-IF-FALSE])
3811 # ------------------------------------------------------------
3812 # Check that the linker support an argument
3813 
3814 
3815 
3816 
3817 #
3818 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3819 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3820 #
3821 # This code is free software; you can redistribute it and/or modify it
3822 # under the terms of the GNU General Public License version 2 only, as
3823 # published by the Free Software Foundation.  Oracle designates this
3824 # particular file as subject to the "Classpath" exception as provided
3825 # by Oracle in the LICENSE file that accompanied this code.
3826 #
3827 # This code is distributed in the hope that it will be useful, but WITHOUT
3828 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3829 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3830 # version 2 for more details (a copy is included in the LICENSE file that
3831 # accompanied this code).
3832 #
3833 # You should have received a copy of the GNU General Public License version
3834 # 2 along with this work; if not, write to the Free Software Foundation,
3835 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3836 #
3837 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3838 # or visit www.oracle.com if you need additional information or have any
3839 # questions.
3840 #
3841 
3842 
3843 
3844 
3845 
3846 cygwin_help() {
3847   case $1 in
3848     unzip)
3849       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P unzip )"
3850       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3851       ;;
3852     zip)
3853       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P zip )"
3854       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3855       ;;
3856     make)
3857       PKGHANDLER_COMMAND="( cd <location of cygwin setup.exe> && cmd /c setup -q -P make )"
3858       HELP_MSG="You might be able to fix this by running '$PKGHANDLER_COMMAND'."
3859       ;;
3860     freetype)
3861       HELP_MSG="
3862 The freetype library can now be build during the configure process.
3863 Download the freetype sources and unpack them into an arbitrary directory:
3864 
3865 wget http://download.savannah.gnu.org/releases/freetype/freetype-2.5.3.tar.gz
3866 tar -xzf freetype-2.5.3.tar.gz
3867 
3868 Then run configure with '--with-freetype-src=<freetype_src>'. This will
3869 automatically build the freetype library into '<freetype_src>/lib64' for 64-bit
3870 builds or into '<freetype_src>/lib32' for 32-bit builds.
3871 Afterwards you can always use '--with-freetype-include=<freetype_src>/include'
3872 and '--with-freetype-lib=<freetype_src>/lib32|64' for other builds."
3873       ;;
3874   esac
3875 }
3876 
3877 msys_help() {
3878   PKGHANDLER_COMMAND=""
3879 }
3880 
3881 apt_help() {
3882   case $1 in
3883     devkit)
3884       PKGHANDLER_COMMAND="sudo apt-get install build-essential" ;;
3885     openjdk)
3886       PKGHANDLER_COMMAND="sudo apt-get install openjdk-7-jdk" ;;
3887     alsa)
3888       PKGHANDLER_COMMAND="sudo apt-get install libasound2-dev" ;;
3889     cups)
3890       PKGHANDLER_COMMAND="sudo apt-get install libcups2-dev" ;;
3891     freetype)
3892       PKGHANDLER_COMMAND="sudo apt-get install libfreetype6-dev" ;;
3893     pulse)
3894       PKGHANDLER_COMMAND="sudo apt-get install libpulse-dev" ;;
3895     x11)
3896       PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
3897     ccache)
3898       PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
3899   esac
3900 }
3901 
3902 yum_help() {
3903   case $1 in
3904     devkit)
3905       PKGHANDLER_COMMAND="sudo yum groupinstall \"Development Tools\"" ;;
3906     openjdk)
3907       PKGHANDLER_COMMAND="sudo yum install java-1.7.0-openjdk" ;;
3908     alsa)
3909       PKGHANDLER_COMMAND="sudo yum install alsa-lib-devel" ;;
3910     cups)
3911       PKGHANDLER_COMMAND="sudo yum install cups-devel" ;;
3912     freetype)
3913       PKGHANDLER_COMMAND="sudo yum install freetype-devel" ;;
3914     pulse)
3915       PKGHANDLER_COMMAND="sudo yum install pulseaudio-libs-devel" ;;
3916     x11)
3917       PKGHANDLER_COMMAND="sudo yum install libXtst-devel libXt-devel libXrender-devel libXi-devel" ;;
3918     ccache)
3919       PKGHANDLER_COMMAND="sudo yum install ccache" ;;
3920   esac
3921 }
3922 
3923 port_help() {
3924   PKGHANDLER_COMMAND=""
3925 }
3926 
3927 pkgutil_help() {
3928   PKGHANDLER_COMMAND=""
3929 }
3930 
3931 pkgadd_help() {
3932   PKGHANDLER_COMMAND=""
3933 }
3934 
3935 # This function will check if we're called from the "configure" wrapper while
3936 # printing --help. If so, we will print out additional information that can
3937 # only be extracted within the autoconf script, and then exit. This must be
3938 # called at the very beginning in configure.ac.
3939 
3940 
3941 
3942 
3943 
3944 
3945 #
3946 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3947 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3948 #
3949 # This code is free software; you can redistribute it and/or modify it
3950 # under the terms of the GNU General Public License version 2 only, as
3951 # published by the Free Software Foundation.  Oracle designates this
3952 # particular file as subject to the "Classpath" exception as provided
3953 # by Oracle in the LICENSE file that accompanied this code.
3954 #
3955 # This code is distributed in the hope that it will be useful, but WITHOUT
3956 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3957 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
3958 # version 2 for more details (a copy is included in the LICENSE file that
3959 # accompanied this code).
3960 #
3961 # You should have received a copy of the GNU General Public License version
3962 # 2 along with this work; if not, write to the Free Software Foundation,
3963 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
3964 #
3965 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
3966 # or visit www.oracle.com if you need additional information or have any
3967 # questions.
3968 #
3969 
3970 
3971 
3972 
3973 
3974 
3975 
3976 
3977 
3978 
3979 ###############################################################################
3980 #
3981 # Should we build only OpenJDK even if closed sources are present?
3982 #
3983 
3984 
3985 
3986 
3987 ###############################################################################
3988 #
3989 # Setup version numbers
3990 #
3991 
3992 
3993 
3994 
3995 
3996 
3997 #
3998 # Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
3999 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4000 #
4001 # This code is free software; you can redistribute it and/or modify it
4002 # under the terms of the GNU General Public License version 2 only, as
4003 # published by the Free Software Foundation.  Oracle designates this
4004 # particular file as subject to the "Classpath" exception as provided
4005 # by Oracle in the LICENSE file that accompanied this code.
4006 #
4007 # This code is distributed in the hope that it will be useful, but WITHOUT
4008 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4009 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4010 # version 2 for more details (a copy is included in the LICENSE file that
4011 # accompanied this code).
4012 #
4013 # You should have received a copy of the GNU General Public License version
4014 # 2 along with this work; if not, write to the Free Software Foundation,
4015 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4016 #
4017 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4018 # or visit www.oracle.com if you need additional information or have any
4019 # questions.
4020 #
4021 
4022 
4023 
4024 
4025 
4026 
4027 
4028 
4029 
4030 
4031 
4032 
4033 
4034 
4035 
4036 
4037 
4038 
4039 
4040 
4041 
4042 #
4043 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4044 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4045 #
4046 # This code is free software; you can redistribute it and/or modify it
4047 # under the terms of the GNU General Public License version 2 only, as
4048 # published by the Free Software Foundation.  Oracle designates this
4049 # particular file as subject to the "Classpath" exception as provided
4050 # by Oracle in the LICENSE file that accompanied this code.
4051 #
4052 # This code is distributed in the hope that it will be useful, but WITHOUT
4053 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4054 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4055 # version 2 for more details (a copy is included in the LICENSE file that
4056 # accompanied this code).
4057 #
4058 # You should have received a copy of the GNU General Public License version
4059 # 2 along with this work; if not, write to the Free Software Foundation,
4060 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4061 #
4062 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4063 # or visit www.oracle.com if you need additional information or have any
4064 # questions.
4065 #
4066 
4067 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4068 # Converts autoconf style CPU name to OpenJDK style, into
4069 # VAR_CPU, VAR_CPU_ARCH, VAR_CPU_BITS and VAR_CPU_ENDIAN.
4070 
4071 
4072 # Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
4073 # Converts autoconf style OS name to OpenJDK style, into
4074 # VAR_OS, VAR_OS_TYPE and VAR_OS_ENV.
4075 
4076 
4077 # Expects $host_os $host_cpu $build_os and $build_cpu
4078 # and $with_target_bits to have been setup!
4079 #
4080 # Translate the standard triplet(quadruplet) definition
4081 # of the target/build system into OPENJDK_TARGET_OS, OPENJDK_TARGET_CPU,
4082 # OPENJDK_BUILD_OS, etc.
4083 
4084 
4085 # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
4086 # accordingly. Must be done after setting up build and target system, but before
4087 # doing anything else with these values.
4088 
4089 
4090 # Setup the legacy variables, for controlling the old makefiles.
4091 #
4092 
4093 
4094 
4095 
4096 #%%% Build and target systems %%%
4097 
4098 
4099 
4100 
4101 # Support macro for PLATFORM_SETUP_OPENJDK_TARGET_BITS.
4102 # Add -mX to various FLAGS variables.
4103 
4104 
4105 
4106 
4107 
4108 
4109 #
4110 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4111 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4112 #
4113 # This code is free software; you can redistribute it and/or modify it
4114 # under the terms of the GNU General Public License version 2 only, as
4115 # published by the Free Software Foundation.  Oracle designates this
4116 # particular file as subject to the "Classpath" exception as provided
4117 # by Oracle in the LICENSE file that accompanied this code.
4118 #
4119 # This code is distributed in the hope that it will be useful, but WITHOUT
4120 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4121 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4122 # version 2 for more details (a copy is included in the LICENSE file that
4123 # accompanied this code).
4124 #
4125 # You should have received a copy of the GNU General Public License version
4126 # 2 along with this work; if not, write to the Free Software Foundation,
4127 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4128 #
4129 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4130 # or visit www.oracle.com if you need additional information or have any
4131 # questions.
4132 #
4133 
4134 
4135 
4136 
4137 
4138 
4139 
4140 
4141 #
4142 # Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
4143 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4144 #
4145 # This code is free software; you can redistribute it and/or modify it
4146 # under the terms of the GNU General Public License version 2 only, as
4147 # published by the Free Software Foundation.  Oracle designates this
4148 # particular file as subject to the "Classpath" exception as provided
4149 # by Oracle in the LICENSE file that accompanied this code.
4150 #
4151 # This code is distributed in the hope that it will be useful, but WITHOUT
4152 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4153 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4154 # version 2 for more details (a copy is included in the LICENSE file that
4155 # accompanied this code).
4156 #
4157 # You should have received a copy of the GNU General Public License version
4158 # 2 along with this work; if not, write to the Free Software Foundation,
4159 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4160 #
4161 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4162 # or visit www.oracle.com if you need additional information or have any
4163 # questions.
4164 #
4165 
4166 ########################################################################
4167 # This file is responsible for detecting, verifying and setting up the
4168 # toolchain, i.e. the compiler, linker and related utilities. It will setup
4169 # proper paths to the binaries, but it will not setup any flags.
4170 #
4171 # The binaries used is determined by the toolchain type, which is the family of
4172 # compilers and related tools that are used.
4173 ########################################################################
4174 
4175 
4176 # All valid toolchains, regardless of platform (used by help.m4)
4177 VALID_TOOLCHAINS_all="gcc clang solstudio xlc microsoft"
4178 
4179 # These toolchains are valid on different platforms
4180 VALID_TOOLCHAINS_linux="gcc clang"
4181 VALID_TOOLCHAINS_solaris="solstudio"
4182 VALID_TOOLCHAINS_macosx="gcc clang"
4183 VALID_TOOLCHAINS_aix="xlc"
4184 VALID_TOOLCHAINS_windows="microsoft"
4185 
4186 # Toolchain descriptions
4187 TOOLCHAIN_DESCRIPTION_clang="clang/LLVM"
4188 TOOLCHAIN_DESCRIPTION_gcc="GNU Compiler Collection"
4189 TOOLCHAIN_DESCRIPTION_microsoft="Microsoft Visual Studio"
4190 TOOLCHAIN_DESCRIPTION_solstudio="Oracle Solaris Studio"
4191 TOOLCHAIN_DESCRIPTION_xlc="IBM XL C/C++"
4192 
4193 # Setup a number of variables describing how native output files are
4194 # named on this platform/toolchain.
4195 
4196 
4197 # Determine which toolchain type to use, and make sure it is valid for this
4198 # platform. Setup various information about the selected toolchain.
4199 
4200 
4201 # Before we start detecting the toolchain executables, we might need some
4202 # special setup, e.g. additional paths etc.
4203 
4204 
4205 # Restore path, etc
4206 
4207 
4208 # Check if a compiler is of the toolchain type we expect, and save the version
4209 # information from it. If the compiler does not match the expected type,
4210 # this function will abort using AC_MSG_ERROR. If it matches, the version will
4211 # be stored in CC_VERSION_NUMBER/CXX_VERSION_NUMBER (as a dotted number), and
4212 # the full version string in CC_VERSION_STRING/CXX_VERSION_STRING.
4213 #
4214 # $1 = compiler to test (CC or CXX)
4215 # $2 = human readable name of compiler (C or C++)
4216 
4217 
4218 # Try to locate the given C or C++ compiler in the path, or otherwise.
4219 #
4220 # $1 = compiler to test (CC or CXX)
4221 # $2 = human readable name of compiler (C or C++)
4222 # $3 = list of compiler names to search for
4223 
4224 
4225 # Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
4226 # preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
4227 # archiver (AR). Verify that the compilers are correct according to the
4228 # toolchain type.
4229 
4230 
4231 # Setup additional tools that is considered a part of the toolchain, but not the
4232 # core part. Many of these are highly platform-specific and do not exist,
4233 # and/or are not needed on all platforms.
4234 
4235 
4236 # Setup the build tools (i.e, the compiler and linker used to build programs
4237 # that should be run on the build platform, not the target platform, as a build
4238 # helper). Since the non-cross-compile case uses the normal, target compilers
4239 # for this, we can only do this after these have been setup.
4240 
4241 
4242 # Setup legacy variables that are still needed as alternative ways to refer to
4243 # parts of the toolchain.
4244 
4245 
4246 # Do some additional checks on the detected tools.
4247 
4248 
4249 # Setup the JTReg Regression Test Harness.
4250 
4251 
4252 #
4253 # Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
4254 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4255 #
4256 # This code is free software; you can redistribute it and/or modify it
4257 # under the terms of the GNU General Public License version 2 only, as
4258 # published by the Free Software Foundation.  Oracle designates this
4259 # particular file as subject to the "Classpath" exception as provided
4260 # by Oracle in the LICENSE file that accompanied this code.
4261 #
4262 # This code is distributed in the hope that it will be useful, but WITHOUT
4263 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4264 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4265 # version 2 for more details (a copy is included in the LICENSE file that
4266 # accompanied this code).
4267 #
4268 # You should have received a copy of the GNU General Public License version
4269 # 2 along with this work; if not, write to the Free Software Foundation,
4270 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4271 #
4272 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
4273 # or visit www.oracle.com if you need additional information or have any
4274 # questions.
4275 #
4276 
4277 ################################################################################
4278 
4279 VALID_VS_VERSIONS="2010 2012 2013"
4280 
4281 VS_DESCRIPTION_2010="Microsoft Visual Studio 2010"
4282 VS_VERSION_INTERNAL_2010=100
4283 VS_MSVCR_2010=msvcr100.dll
4284 # We don't use msvcp on Visual Studio 2010
4285 #VS_MSVCP_2010=msvcp100.dll
4286 VS_ENVVAR_2010="VS100COMNTOOLS"
4287 VS_VS_INSTALLDIR_2010="Microsoft Visual Studio 10.0"
4288 VS_SDK_INSTALLDIR_2010="Microsoft SDKs/Windows/v7.1"
4289 VS_VS_PLATFORM_NAME_2010="v100"
4290 VS_SDK_PLATFORM_NAME_2010="Windows7.1SDK"
4291 
4292 VS_DESCRIPTION_2012="Microsoft Visual Studio 2012"
4293 VS_VERSION_INTERNAL_2012=110
4294 VS_MSVCR_2012=msvcr110.dll
4295 VS_MSVCP_2012=msvcp110.dll
4296 VS_ENVVAR_2012="VS110COMNTOOLS"
4297 VS_VS_INSTALLDIR_2012="Microsoft Visual Studio 11.0"
4298 VS_SDK_INSTALLDIR_2012=
4299 VS_VS_PLATFORM_NAME_2012="v110"
4300 VS_SDK_PLATFORM_NAME_2012=
4301 
4302 VS_DESCRIPTION_2013="Microsoft Visual Studio 2013"
4303 VS_VERSION_INTERNAL_2013=120
4304 VS_MSVCR_2013=msvcr120.dll
4305 VS_MSVCP_2013=msvcp120.dll
4306 VS_ENVVAR_2013="VS120COMNTOOLS"
4307 VS_VS_INSTALLDIR_2013="Microsoft Visual Studio 12.0"
4308 VS_SDK_INSTALLDIR_2013=
4309 VS_VS_PLATFORM_NAME_2013="v120"
4310 VS_SDK_PLATFORM_NAME_2013=
4311 
4312 ################################################################################
4313 
4314 
4315 
4316 ################################################################################
4317 
4318 
4319 
4320 ################################################################################
4321 # Finds the bat or cmd file in Visual Studio or the SDK that sets up a proper
4322 # build environment and assigns it to VS_ENV_CMD
4323 
4324 
4325 ################################################################################
4326 
4327 
4328 
4329 ################################################################################
4330 # Check if the VS env variables were setup prior to running configure.
4331 # If not, then find vcvarsall.bat and run it automatically, and integrate
4332 # the set env variables into the spec file.
4333 
4334 
4335 
4336 
4337 
4338 
4339 
4340 
4341 
4342 
4343 
4344 
4345 
4346 # This line needs to be here, verbatim, after all includes and the dummy hook
4347 # definitions. It is replaced with custom functionality when building
4348 # custom sources.
4349 #CUSTOM_AUTOCONF_INCLUDE
4350 
4351 # Do not change or remove the following line, it is needed for consistency checks:
4352 DATE_WHEN_GENERATED=1425658225
4353 
4354 ###############################################################################
4355 #
4356 # Initialization / Boot-strapping
4357 #
4358 # The bootstrapping process needs to solve the "chicken or the egg" problem,
4359 # thus it jumps back and forth, each time gaining something needed later on.
4360 #
4361 ###############################################################################
4362 
4363 # If we are requested to print additional help, do that and then exit.
4364 # This must be the very first call.
4365 
4366   if test "x$CONFIGURE_PRINT_TOOLCHAIN_LIST" != x; then
4367     $PRINTF "The following toolchains are available as arguments to --with-toolchain-type.\n"
4368     $PRINTF "Which are valid to use depends on the build platform.\n"
4369     for toolchain in $VALID_TOOLCHAINS_all; do
4370       # Use indirect variable referencing
4371       toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
4372       TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
4373       $PRINTF "  %-10s  %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
4374     done
4375 
4376     # And now exit directly
4377     exit 0
4378   fi
4379 
4380 
4381 # Basic initialization that must happen first of all in the normal process.
4382 
4383   # Save the original command line. This is passed to us by the wrapper configure script.
4384 
4385   # Save the path variable before it gets changed
4386   ORIGINAL_PATH="$PATH"
4387 
4388   DATE_WHEN_CONFIGURED=`LANG=C date`
4389 
4390   { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
4391 $as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
4392   { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
4393 $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
4394 
4395 
4396   # Start with tools that do not need have cross compilation support
4397   # and can be expected to be found in the default PATH. These tools are
4398   # used by configure. Nor are these tools expected to be found in the
4399   # devkit from the builddeps server either, since they are
4400   # needed to download the devkit.
4401 
4402   # First are all the simple required tools.
4403 
4404 
4405 
4406   # Publish this variable in the help.
4407 
4408 
4409   if test "x$BASENAME" = x; then
4410     # The variable is not set by user, try to locate tool using the code snippet
4411     for ac_prog in basename
4412 do
4413   # Extract the first word of "$ac_prog", so it can be a program name with args.
4414 set dummy $ac_prog; ac_word=$2
4415 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4416 $as_echo_n "checking for $ac_word... " >&6; }
4417 if ${ac_cv_path_BASENAME+:} false; then :
4418   $as_echo_n "(cached) " >&6
4419 else
4420   case $BASENAME in
4421   [\\/]* | ?:[\\/]*)
4422   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4423   ;;
4424   *)
4425   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4426 for as_dir in $PATH
4427 do
4428   IFS=$as_save_IFS
4429   test -z "$as_dir" && as_dir=.
4430     for ac_exec_ext in '' $ac_executable_extensions; do
4431   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4432     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4433     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4434     break 2
4435   fi
4436 done
4437   done
4438 IFS=$as_save_IFS
4439 
4440   ;;
4441 esac
4442 fi
4443 BASENAME=$ac_cv_path_BASENAME
4444 if test -n "$BASENAME"; then
4445   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4446 $as_echo "$BASENAME" >&6; }
4447 else
4448   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4449 $as_echo "no" >&6; }
4450 fi
4451 
4452 
4453   test -n "$BASENAME" && break
4454 done
4455 
4456   else
4457     # The variable is set, but is it from the command line or the environment?
4458 
4459     # Try to remove the string !BASENAME! from our list.
4460     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASENAME!/}
4461     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4462       # If it failed, the variable was not from the command line. Ignore it,
4463       # but warn the user (except for BASH, which is always set by the calling BASH).
4464       if test "xBASENAME" != xBASH; then
4465         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
4466 $as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
4467       fi
4468       # Try to locate tool using the code snippet
4469       for ac_prog in basename
4470 do
4471   # Extract the first word of "$ac_prog", so it can be a program name with args.
4472 set dummy $ac_prog; ac_word=$2
4473 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4474 $as_echo_n "checking for $ac_word... " >&6; }
4475 if ${ac_cv_path_BASENAME+:} false; then :
4476   $as_echo_n "(cached) " >&6
4477 else
4478   case $BASENAME in
4479   [\\/]* | ?:[\\/]*)
4480   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4481   ;;
4482   *)
4483   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4484 for as_dir in $PATH
4485 do
4486   IFS=$as_save_IFS
4487   test -z "$as_dir" && as_dir=.
4488     for ac_exec_ext in '' $ac_executable_extensions; do
4489   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4490     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4491     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4492     break 2
4493   fi
4494 done
4495   done
4496 IFS=$as_save_IFS
4497 
4498   ;;
4499 esac
4500 fi
4501 BASENAME=$ac_cv_path_BASENAME
4502 if test -n "$BASENAME"; then
4503   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4504 $as_echo "$BASENAME" >&6; }
4505 else
4506   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4507 $as_echo "no" >&6; }
4508 fi
4509 
4510 
4511   test -n "$BASENAME" && break
4512 done
4513 
4514     else
4515       # If it succeeded, then it was overridden by the user. We will use it
4516       # for the tool.
4517 
4518       # First remove it from the list of overridden variables, so we can test
4519       # for unknown variables in the end.
4520       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4521 
4522       # Check if the provided tool contains a complete path.
4523       tool_specified="$BASENAME"
4524       tool_basename="${tool_specified##*/}"
4525       if test "x$tool_basename" = "x$tool_specified"; then
4526         # A command without a complete path is provided, search $PATH.
4527         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
4528 $as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
4529         # Extract the first word of "$tool_basename", so it can be a program name with args.
4530 set dummy $tool_basename; ac_word=$2
4531 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4532 $as_echo_n "checking for $ac_word... " >&6; }
4533 if ${ac_cv_path_BASENAME+:} false; then :
4534   $as_echo_n "(cached) " >&6
4535 else
4536   case $BASENAME in
4537   [\\/]* | ?:[\\/]*)
4538   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
4539   ;;
4540   *)
4541   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4542 for as_dir in $PATH
4543 do
4544   IFS=$as_save_IFS
4545   test -z "$as_dir" && as_dir=.
4546     for ac_exec_ext in '' $ac_executable_extensions; do
4547   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4548     ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
4549     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4550     break 2
4551   fi
4552 done
4553   done
4554 IFS=$as_save_IFS
4555 
4556   ;;
4557 esac
4558 fi
4559 BASENAME=$ac_cv_path_BASENAME
4560 if test -n "$BASENAME"; then
4561   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
4562 $as_echo "$BASENAME" >&6; }
4563 else
4564   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4565 $as_echo "no" >&6; }
4566 fi
4567 
4568 
4569         if test "x$BASENAME" = x; then
4570           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4571         fi
4572       else
4573         # Otherwise we believe it is a complete path. Use it as it is.
4574         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
4575 $as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
4576         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
4577 $as_echo_n "checking for BASENAME... " >&6; }
4578         if test ! -x "$tool_specified"; then
4579           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4580 $as_echo "not found" >&6; }
4581           as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
4582         fi
4583         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4584 $as_echo "$tool_specified" >&6; }
4585       fi
4586     fi
4587   fi
4588 
4589 
4590 
4591   if test "x$BASENAME" = x; then
4592     as_fn_error $? "Could not find required tool for BASENAME" "$LINENO" 5
4593   fi
4594 
4595 
4596 
4597 
4598 
4599   # Publish this variable in the help.
4600 
4601 
4602   if test "x$BASH" = x; then
4603     # The variable is not set by user, try to locate tool using the code snippet
4604     for ac_prog in bash
4605 do
4606   # Extract the first word of "$ac_prog", so it can be a program name with args.
4607 set dummy $ac_prog; ac_word=$2
4608 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4609 $as_echo_n "checking for $ac_word... " >&6; }
4610 if ${ac_cv_path_BASH+:} false; then :
4611   $as_echo_n "(cached) " >&6
4612 else
4613   case $BASH in
4614   [\\/]* | ?:[\\/]*)
4615   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4616   ;;
4617   *)
4618   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4619 for as_dir in $PATH
4620 do
4621   IFS=$as_save_IFS
4622   test -z "$as_dir" && as_dir=.
4623     for ac_exec_ext in '' $ac_executable_extensions; do
4624   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4625     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4626     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4627     break 2
4628   fi
4629 done
4630   done
4631 IFS=$as_save_IFS
4632 
4633   ;;
4634 esac
4635 fi
4636 BASH=$ac_cv_path_BASH
4637 if test -n "$BASH"; then
4638   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4639 $as_echo "$BASH" >&6; }
4640 else
4641   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4642 $as_echo "no" >&6; }
4643 fi
4644 
4645 
4646   test -n "$BASH" && break
4647 done
4648 
4649   else
4650     # The variable is set, but is it from the command line or the environment?
4651 
4652     # Try to remove the string !BASH! from our list.
4653     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!BASH!/}
4654     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4655       # If it failed, the variable was not from the command line. Ignore it,
4656       # but warn the user (except for BASH, which is always set by the calling BASH).
4657       if test "xBASH" != xBASH; then
4658         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
4659 $as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
4660       fi
4661       # Try to locate tool using the code snippet
4662       for ac_prog in bash
4663 do
4664   # Extract the first word of "$ac_prog", so it can be a program name with args.
4665 set dummy $ac_prog; ac_word=$2
4666 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4667 $as_echo_n "checking for $ac_word... " >&6; }
4668 if ${ac_cv_path_BASH+:} false; then :
4669   $as_echo_n "(cached) " >&6
4670 else
4671   case $BASH in
4672   [\\/]* | ?:[\\/]*)
4673   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4674   ;;
4675   *)
4676   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4677 for as_dir in $PATH
4678 do
4679   IFS=$as_save_IFS
4680   test -z "$as_dir" && as_dir=.
4681     for ac_exec_ext in '' $ac_executable_extensions; do
4682   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4683     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4684     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4685     break 2
4686   fi
4687 done
4688   done
4689 IFS=$as_save_IFS
4690 
4691   ;;
4692 esac
4693 fi
4694 BASH=$ac_cv_path_BASH
4695 if test -n "$BASH"; then
4696   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4697 $as_echo "$BASH" >&6; }
4698 else
4699   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4700 $as_echo "no" >&6; }
4701 fi
4702 
4703 
4704   test -n "$BASH" && break
4705 done
4706 
4707     else
4708       # If it succeeded, then it was overridden by the user. We will use it
4709       # for the tool.
4710 
4711       # First remove it from the list of overridden variables, so we can test
4712       # for unknown variables in the end.
4713       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4714 
4715       # Check if the provided tool contains a complete path.
4716       tool_specified="$BASH"
4717       tool_basename="${tool_specified##*/}"
4718       if test "x$tool_basename" = "x$tool_specified"; then
4719         # A command without a complete path is provided, search $PATH.
4720         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
4721 $as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
4722         # Extract the first word of "$tool_basename", so it can be a program name with args.
4723 set dummy $tool_basename; ac_word=$2
4724 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4725 $as_echo_n "checking for $ac_word... " >&6; }
4726 if ${ac_cv_path_BASH+:} false; then :
4727   $as_echo_n "(cached) " >&6
4728 else
4729   case $BASH in
4730   [\\/]* | ?:[\\/]*)
4731   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
4732   ;;
4733   *)
4734   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4735 for as_dir in $PATH
4736 do
4737   IFS=$as_save_IFS
4738   test -z "$as_dir" && as_dir=.
4739     for ac_exec_ext in '' $ac_executable_extensions; do
4740   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4741     ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
4742     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4743     break 2
4744   fi
4745 done
4746   done
4747 IFS=$as_save_IFS
4748 
4749   ;;
4750 esac
4751 fi
4752 BASH=$ac_cv_path_BASH
4753 if test -n "$BASH"; then
4754   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
4755 $as_echo "$BASH" >&6; }
4756 else
4757   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4758 $as_echo "no" >&6; }
4759 fi
4760 
4761 
4762         if test "x$BASH" = x; then
4763           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4764         fi
4765       else
4766         # Otherwise we believe it is a complete path. Use it as it is.
4767         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
4768 $as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
4769         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
4770 $as_echo_n "checking for BASH... " >&6; }
4771         if test ! -x "$tool_specified"; then
4772           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4773 $as_echo "not found" >&6; }
4774           as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
4775         fi
4776         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4777 $as_echo "$tool_specified" >&6; }
4778       fi
4779     fi
4780   fi
4781 
4782 
4783 
4784   if test "x$BASH" = x; then
4785     as_fn_error $? "Could not find required tool for BASH" "$LINENO" 5
4786   fi
4787 
4788 
4789 
4790 
4791 
4792   # Publish this variable in the help.
4793 
4794 
4795   if test "x$CAT" = x; then
4796     # The variable is not set by user, try to locate tool using the code snippet
4797     for ac_prog in cat
4798 do
4799   # Extract the first word of "$ac_prog", so it can be a program name with args.
4800 set dummy $ac_prog; ac_word=$2
4801 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4802 $as_echo_n "checking for $ac_word... " >&6; }
4803 if ${ac_cv_path_CAT+:} false; then :
4804   $as_echo_n "(cached) " >&6
4805 else
4806   case $CAT in
4807   [\\/]* | ?:[\\/]*)
4808   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4809   ;;
4810   *)
4811   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4812 for as_dir in $PATH
4813 do
4814   IFS=$as_save_IFS
4815   test -z "$as_dir" && as_dir=.
4816     for ac_exec_ext in '' $ac_executable_extensions; do
4817   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4818     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4819     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4820     break 2
4821   fi
4822 done
4823   done
4824 IFS=$as_save_IFS
4825 
4826   ;;
4827 esac
4828 fi
4829 CAT=$ac_cv_path_CAT
4830 if test -n "$CAT"; then
4831   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4832 $as_echo "$CAT" >&6; }
4833 else
4834   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4835 $as_echo "no" >&6; }
4836 fi
4837 
4838 
4839   test -n "$CAT" && break
4840 done
4841 
4842   else
4843     # The variable is set, but is it from the command line or the environment?
4844 
4845     # Try to remove the string !CAT! from our list.
4846     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CAT!/}
4847     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
4848       # If it failed, the variable was not from the command line. Ignore it,
4849       # but warn the user (except for BASH, which is always set by the calling BASH).
4850       if test "xCAT" != xBASH; then
4851         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
4852 $as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
4853       fi
4854       # Try to locate tool using the code snippet
4855       for ac_prog in cat
4856 do
4857   # Extract the first word of "$ac_prog", so it can be a program name with args.
4858 set dummy $ac_prog; ac_word=$2
4859 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4860 $as_echo_n "checking for $ac_word... " >&6; }
4861 if ${ac_cv_path_CAT+:} false; then :
4862   $as_echo_n "(cached) " >&6
4863 else
4864   case $CAT in
4865   [\\/]* | ?:[\\/]*)
4866   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4867   ;;
4868   *)
4869   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4870 for as_dir in $PATH
4871 do
4872   IFS=$as_save_IFS
4873   test -z "$as_dir" && as_dir=.
4874     for ac_exec_ext in '' $ac_executable_extensions; do
4875   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4876     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4877     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4878     break 2
4879   fi
4880 done
4881   done
4882 IFS=$as_save_IFS
4883 
4884   ;;
4885 esac
4886 fi
4887 CAT=$ac_cv_path_CAT
4888 if test -n "$CAT"; then
4889   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4890 $as_echo "$CAT" >&6; }
4891 else
4892   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4893 $as_echo "no" >&6; }
4894 fi
4895 
4896 
4897   test -n "$CAT" && break
4898 done
4899 
4900     else
4901       # If it succeeded, then it was overridden by the user. We will use it
4902       # for the tool.
4903 
4904       # First remove it from the list of overridden variables, so we can test
4905       # for unknown variables in the end.
4906       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
4907 
4908       # Check if the provided tool contains a complete path.
4909       tool_specified="$CAT"
4910       tool_basename="${tool_specified##*/}"
4911       if test "x$tool_basename" = "x$tool_specified"; then
4912         # A command without a complete path is provided, search $PATH.
4913         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
4914 $as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
4915         # Extract the first word of "$tool_basename", so it can be a program name with args.
4916 set dummy $tool_basename; ac_word=$2
4917 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4918 $as_echo_n "checking for $ac_word... " >&6; }
4919 if ${ac_cv_path_CAT+:} false; then :
4920   $as_echo_n "(cached) " >&6
4921 else
4922   case $CAT in
4923   [\\/]* | ?:[\\/]*)
4924   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
4925   ;;
4926   *)
4927   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4928 for as_dir in $PATH
4929 do
4930   IFS=$as_save_IFS
4931   test -z "$as_dir" && as_dir=.
4932     for ac_exec_ext in '' $ac_executable_extensions; do
4933   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4934     ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
4935     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4936     break 2
4937   fi
4938 done
4939   done
4940 IFS=$as_save_IFS
4941 
4942   ;;
4943 esac
4944 fi
4945 CAT=$ac_cv_path_CAT
4946 if test -n "$CAT"; then
4947   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
4948 $as_echo "$CAT" >&6; }
4949 else
4950   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4951 $as_echo "no" >&6; }
4952 fi
4953 
4954 
4955         if test "x$CAT" = x; then
4956           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
4957         fi
4958       else
4959         # Otherwise we believe it is a complete path. Use it as it is.
4960         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
4961 $as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
4962         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
4963 $as_echo_n "checking for CAT... " >&6; }
4964         if test ! -x "$tool_specified"; then
4965           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
4966 $as_echo "not found" >&6; }
4967           as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
4968         fi
4969         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
4970 $as_echo "$tool_specified" >&6; }
4971       fi
4972     fi
4973   fi
4974 
4975 
4976 
4977   if test "x$CAT" = x; then
4978     as_fn_error $? "Could not find required tool for CAT" "$LINENO" 5
4979   fi
4980 
4981 
4982 
4983 
4984 
4985   # Publish this variable in the help.
4986 
4987 
4988   if test "x$CHMOD" = x; then
4989     # The variable is not set by user, try to locate tool using the code snippet
4990     for ac_prog in chmod
4991 do
4992   # Extract the first word of "$ac_prog", so it can be a program name with args.
4993 set dummy $ac_prog; ac_word=$2
4994 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4995 $as_echo_n "checking for $ac_word... " >&6; }
4996 if ${ac_cv_path_CHMOD+:} false; then :
4997   $as_echo_n "(cached) " >&6
4998 else
4999   case $CHMOD in
5000   [\\/]* | ?:[\\/]*)
5001   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5002   ;;
5003   *)
5004   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5005 for as_dir in $PATH
5006 do
5007   IFS=$as_save_IFS
5008   test -z "$as_dir" && as_dir=.
5009     for ac_exec_ext in '' $ac_executable_extensions; do
5010   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5011     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5012     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5013     break 2
5014   fi
5015 done
5016   done
5017 IFS=$as_save_IFS
5018 
5019   ;;
5020 esac
5021 fi
5022 CHMOD=$ac_cv_path_CHMOD
5023 if test -n "$CHMOD"; then
5024   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5025 $as_echo "$CHMOD" >&6; }
5026 else
5027   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5028 $as_echo "no" >&6; }
5029 fi
5030 
5031 
5032   test -n "$CHMOD" && break
5033 done
5034 
5035   else
5036     # The variable is set, but is it from the command line or the environment?
5037 
5038     # Try to remove the string !CHMOD! from our list.
5039     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CHMOD!/}
5040     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5041       # If it failed, the variable was not from the command line. Ignore it,
5042       # but warn the user (except for BASH, which is always set by the calling BASH).
5043       if test "xCHMOD" != xBASH; then
5044         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
5045 $as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
5046       fi
5047       # Try to locate tool using the code snippet
5048       for ac_prog in chmod
5049 do
5050   # Extract the first word of "$ac_prog", so it can be a program name with args.
5051 set dummy $ac_prog; ac_word=$2
5052 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5053 $as_echo_n "checking for $ac_word... " >&6; }
5054 if ${ac_cv_path_CHMOD+:} false; then :
5055   $as_echo_n "(cached) " >&6
5056 else
5057   case $CHMOD in
5058   [\\/]* | ?:[\\/]*)
5059   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5060   ;;
5061   *)
5062   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5063 for as_dir in $PATH
5064 do
5065   IFS=$as_save_IFS
5066   test -z "$as_dir" && as_dir=.
5067     for ac_exec_ext in '' $ac_executable_extensions; do
5068   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5069     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5070     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5071     break 2
5072   fi
5073 done
5074   done
5075 IFS=$as_save_IFS
5076 
5077   ;;
5078 esac
5079 fi
5080 CHMOD=$ac_cv_path_CHMOD
5081 if test -n "$CHMOD"; then
5082   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5083 $as_echo "$CHMOD" >&6; }
5084 else
5085   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5086 $as_echo "no" >&6; }
5087 fi
5088 
5089 
5090   test -n "$CHMOD" && break
5091 done
5092 
5093     else
5094       # If it succeeded, then it was overridden by the user. We will use it
5095       # for the tool.
5096 
5097       # First remove it from the list of overridden variables, so we can test
5098       # for unknown variables in the end.
5099       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5100 
5101       # Check if the provided tool contains a complete path.
5102       tool_specified="$CHMOD"
5103       tool_basename="${tool_specified##*/}"
5104       if test "x$tool_basename" = "x$tool_specified"; then
5105         # A command without a complete path is provided, search $PATH.
5106         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
5107 $as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
5108         # Extract the first word of "$tool_basename", so it can be a program name with args.
5109 set dummy $tool_basename; ac_word=$2
5110 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5111 $as_echo_n "checking for $ac_word... " >&6; }
5112 if ${ac_cv_path_CHMOD+:} false; then :
5113   $as_echo_n "(cached) " >&6
5114 else
5115   case $CHMOD in
5116   [\\/]* | ?:[\\/]*)
5117   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
5118   ;;
5119   *)
5120   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5121 for as_dir in $PATH
5122 do
5123   IFS=$as_save_IFS
5124   test -z "$as_dir" && as_dir=.
5125     for ac_exec_ext in '' $ac_executable_extensions; do
5126   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5127     ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
5128     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5129     break 2
5130   fi
5131 done
5132   done
5133 IFS=$as_save_IFS
5134 
5135   ;;
5136 esac
5137 fi
5138 CHMOD=$ac_cv_path_CHMOD
5139 if test -n "$CHMOD"; then
5140   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
5141 $as_echo "$CHMOD" >&6; }
5142 else
5143   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5144 $as_echo "no" >&6; }
5145 fi
5146 
5147 
5148         if test "x$CHMOD" = x; then
5149           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5150         fi
5151       else
5152         # Otherwise we believe it is a complete path. Use it as it is.
5153         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
5154 $as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
5155         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
5156 $as_echo_n "checking for CHMOD... " >&6; }
5157         if test ! -x "$tool_specified"; then
5158           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5159 $as_echo "not found" >&6; }
5160           as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
5161         fi
5162         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5163 $as_echo "$tool_specified" >&6; }
5164       fi
5165     fi
5166   fi
5167 
5168 
5169 
5170   if test "x$CHMOD" = x; then
5171     as_fn_error $? "Could not find required tool for CHMOD" "$LINENO" 5
5172   fi
5173 
5174 
5175 
5176 
5177 
5178   # Publish this variable in the help.
5179 
5180 
5181   if test "x$CMP" = x; then
5182     # The variable is not set by user, try to locate tool using the code snippet
5183     for ac_prog in cmp
5184 do
5185   # Extract the first word of "$ac_prog", so it can be a program name with args.
5186 set dummy $ac_prog; ac_word=$2
5187 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5188 $as_echo_n "checking for $ac_word... " >&6; }
5189 if ${ac_cv_path_CMP+:} false; then :
5190   $as_echo_n "(cached) " >&6
5191 else
5192   case $CMP in
5193   [\\/]* | ?:[\\/]*)
5194   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5195   ;;
5196   *)
5197   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5198 for as_dir in $PATH
5199 do
5200   IFS=$as_save_IFS
5201   test -z "$as_dir" && as_dir=.
5202     for ac_exec_ext in '' $ac_executable_extensions; do
5203   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5204     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5205     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5206     break 2
5207   fi
5208 done
5209   done
5210 IFS=$as_save_IFS
5211 
5212   ;;
5213 esac
5214 fi
5215 CMP=$ac_cv_path_CMP
5216 if test -n "$CMP"; then
5217   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5218 $as_echo "$CMP" >&6; }
5219 else
5220   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5221 $as_echo "no" >&6; }
5222 fi
5223 
5224 
5225   test -n "$CMP" && break
5226 done
5227 
5228   else
5229     # The variable is set, but is it from the command line or the environment?
5230 
5231     # Try to remove the string !CMP! from our list.
5232     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CMP!/}
5233     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5234       # If it failed, the variable was not from the command line. Ignore it,
5235       # but warn the user (except for BASH, which is always set by the calling BASH).
5236       if test "xCMP" != xBASH; then
5237         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
5238 $as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
5239       fi
5240       # Try to locate tool using the code snippet
5241       for ac_prog in cmp
5242 do
5243   # Extract the first word of "$ac_prog", so it can be a program name with args.
5244 set dummy $ac_prog; ac_word=$2
5245 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5246 $as_echo_n "checking for $ac_word... " >&6; }
5247 if ${ac_cv_path_CMP+:} false; then :
5248   $as_echo_n "(cached) " >&6
5249 else
5250   case $CMP in
5251   [\\/]* | ?:[\\/]*)
5252   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5253   ;;
5254   *)
5255   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5256 for as_dir in $PATH
5257 do
5258   IFS=$as_save_IFS
5259   test -z "$as_dir" && as_dir=.
5260     for ac_exec_ext in '' $ac_executable_extensions; do
5261   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5262     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5263     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5264     break 2
5265   fi
5266 done
5267   done
5268 IFS=$as_save_IFS
5269 
5270   ;;
5271 esac
5272 fi
5273 CMP=$ac_cv_path_CMP
5274 if test -n "$CMP"; then
5275   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5276 $as_echo "$CMP" >&6; }
5277 else
5278   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5279 $as_echo "no" >&6; }
5280 fi
5281 
5282 
5283   test -n "$CMP" && break
5284 done
5285 
5286     else
5287       # If it succeeded, then it was overridden by the user. We will use it
5288       # for the tool.
5289 
5290       # First remove it from the list of overridden variables, so we can test
5291       # for unknown variables in the end.
5292       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5293 
5294       # Check if the provided tool contains a complete path.
5295       tool_specified="$CMP"
5296       tool_basename="${tool_specified##*/}"
5297       if test "x$tool_basename" = "x$tool_specified"; then
5298         # A command without a complete path is provided, search $PATH.
5299         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
5300 $as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
5301         # Extract the first word of "$tool_basename", so it can be a program name with args.
5302 set dummy $tool_basename; ac_word=$2
5303 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5304 $as_echo_n "checking for $ac_word... " >&6; }
5305 if ${ac_cv_path_CMP+:} false; then :
5306   $as_echo_n "(cached) " >&6
5307 else
5308   case $CMP in
5309   [\\/]* | ?:[\\/]*)
5310   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
5311   ;;
5312   *)
5313   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5314 for as_dir in $PATH
5315 do
5316   IFS=$as_save_IFS
5317   test -z "$as_dir" && as_dir=.
5318     for ac_exec_ext in '' $ac_executable_extensions; do
5319   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5320     ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
5321     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5322     break 2
5323   fi
5324 done
5325   done
5326 IFS=$as_save_IFS
5327 
5328   ;;
5329 esac
5330 fi
5331 CMP=$ac_cv_path_CMP
5332 if test -n "$CMP"; then
5333   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
5334 $as_echo "$CMP" >&6; }
5335 else
5336   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5337 $as_echo "no" >&6; }
5338 fi
5339 
5340 
5341         if test "x$CMP" = x; then
5342           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5343         fi
5344       else
5345         # Otherwise we believe it is a complete path. Use it as it is.
5346         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
5347 $as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
5348         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
5349 $as_echo_n "checking for CMP... " >&6; }
5350         if test ! -x "$tool_specified"; then
5351           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5352 $as_echo "not found" >&6; }
5353           as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
5354         fi
5355         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5356 $as_echo "$tool_specified" >&6; }
5357       fi
5358     fi
5359   fi
5360 
5361 
5362 
5363   if test "x$CMP" = x; then
5364     as_fn_error $? "Could not find required tool for CMP" "$LINENO" 5
5365   fi
5366 
5367 
5368 
5369 
5370 
5371   # Publish this variable in the help.
5372 
5373 
5374   if test "x$COMM" = x; then
5375     # The variable is not set by user, try to locate tool using the code snippet
5376     for ac_prog in comm
5377 do
5378   # Extract the first word of "$ac_prog", so it can be a program name with args.
5379 set dummy $ac_prog; ac_word=$2
5380 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5381 $as_echo_n "checking for $ac_word... " >&6; }
5382 if ${ac_cv_path_COMM+:} false; then :
5383   $as_echo_n "(cached) " >&6
5384 else
5385   case $COMM in
5386   [\\/]* | ?:[\\/]*)
5387   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5388   ;;
5389   *)
5390   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5391 for as_dir in $PATH
5392 do
5393   IFS=$as_save_IFS
5394   test -z "$as_dir" && as_dir=.
5395     for ac_exec_ext in '' $ac_executable_extensions; do
5396   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5397     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5398     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5399     break 2
5400   fi
5401 done
5402   done
5403 IFS=$as_save_IFS
5404 
5405   ;;
5406 esac
5407 fi
5408 COMM=$ac_cv_path_COMM
5409 if test -n "$COMM"; then
5410   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5411 $as_echo "$COMM" >&6; }
5412 else
5413   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5414 $as_echo "no" >&6; }
5415 fi
5416 
5417 
5418   test -n "$COMM" && break
5419 done
5420 
5421   else
5422     # The variable is set, but is it from the command line or the environment?
5423 
5424     # Try to remove the string !COMM! from our list.
5425     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!COMM!/}
5426     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5427       # If it failed, the variable was not from the command line. Ignore it,
5428       # but warn the user (except for BASH, which is always set by the calling BASH).
5429       if test "xCOMM" != xBASH; then
5430         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
5431 $as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
5432       fi
5433       # Try to locate tool using the code snippet
5434       for ac_prog in comm
5435 do
5436   # Extract the first word of "$ac_prog", so it can be a program name with args.
5437 set dummy $ac_prog; ac_word=$2
5438 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5439 $as_echo_n "checking for $ac_word... " >&6; }
5440 if ${ac_cv_path_COMM+:} false; then :
5441   $as_echo_n "(cached) " >&6
5442 else
5443   case $COMM in
5444   [\\/]* | ?:[\\/]*)
5445   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5446   ;;
5447   *)
5448   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5449 for as_dir in $PATH
5450 do
5451   IFS=$as_save_IFS
5452   test -z "$as_dir" && as_dir=.
5453     for ac_exec_ext in '' $ac_executable_extensions; do
5454   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5455     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5456     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5457     break 2
5458   fi
5459 done
5460   done
5461 IFS=$as_save_IFS
5462 
5463   ;;
5464 esac
5465 fi
5466 COMM=$ac_cv_path_COMM
5467 if test -n "$COMM"; then
5468   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5469 $as_echo "$COMM" >&6; }
5470 else
5471   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5472 $as_echo "no" >&6; }
5473 fi
5474 
5475 
5476   test -n "$COMM" && break
5477 done
5478 
5479     else
5480       # If it succeeded, then it was overridden by the user. We will use it
5481       # for the tool.
5482 
5483       # First remove it from the list of overridden variables, so we can test
5484       # for unknown variables in the end.
5485       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5486 
5487       # Check if the provided tool contains a complete path.
5488       tool_specified="$COMM"
5489       tool_basename="${tool_specified##*/}"
5490       if test "x$tool_basename" = "x$tool_specified"; then
5491         # A command without a complete path is provided, search $PATH.
5492         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
5493 $as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
5494         # Extract the first word of "$tool_basename", so it can be a program name with args.
5495 set dummy $tool_basename; ac_word=$2
5496 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5497 $as_echo_n "checking for $ac_word... " >&6; }
5498 if ${ac_cv_path_COMM+:} false; then :
5499   $as_echo_n "(cached) " >&6
5500 else
5501   case $COMM in
5502   [\\/]* | ?:[\\/]*)
5503   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
5504   ;;
5505   *)
5506   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5507 for as_dir in $PATH
5508 do
5509   IFS=$as_save_IFS
5510   test -z "$as_dir" && as_dir=.
5511     for ac_exec_ext in '' $ac_executable_extensions; do
5512   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5513     ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
5514     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5515     break 2
5516   fi
5517 done
5518   done
5519 IFS=$as_save_IFS
5520 
5521   ;;
5522 esac
5523 fi
5524 COMM=$ac_cv_path_COMM
5525 if test -n "$COMM"; then
5526   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
5527 $as_echo "$COMM" >&6; }
5528 else
5529   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5530 $as_echo "no" >&6; }
5531 fi
5532 
5533 
5534         if test "x$COMM" = x; then
5535           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5536         fi
5537       else
5538         # Otherwise we believe it is a complete path. Use it as it is.
5539         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
5540 $as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
5541         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
5542 $as_echo_n "checking for COMM... " >&6; }
5543         if test ! -x "$tool_specified"; then
5544           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5545 $as_echo "not found" >&6; }
5546           as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
5547         fi
5548         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5549 $as_echo "$tool_specified" >&6; }
5550       fi
5551     fi
5552   fi
5553 
5554 
5555 
5556   if test "x$COMM" = x; then
5557     as_fn_error $? "Could not find required tool for COMM" "$LINENO" 5
5558   fi
5559 
5560 
5561 
5562 
5563 
5564   # Publish this variable in the help.
5565 
5566 
5567   if test "x$CP" = x; then
5568     # The variable is not set by user, try to locate tool using the code snippet
5569     for ac_prog in cp
5570 do
5571   # Extract the first word of "$ac_prog", so it can be a program name with args.
5572 set dummy $ac_prog; ac_word=$2
5573 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5574 $as_echo_n "checking for $ac_word... " >&6; }
5575 if ${ac_cv_path_CP+:} false; then :
5576   $as_echo_n "(cached) " >&6
5577 else
5578   case $CP in
5579   [\\/]* | ?:[\\/]*)
5580   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5581   ;;
5582   *)
5583   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5584 for as_dir in $PATH
5585 do
5586   IFS=$as_save_IFS
5587   test -z "$as_dir" && as_dir=.
5588     for ac_exec_ext in '' $ac_executable_extensions; do
5589   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5590     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5591     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5592     break 2
5593   fi
5594 done
5595   done
5596 IFS=$as_save_IFS
5597 
5598   ;;
5599 esac
5600 fi
5601 CP=$ac_cv_path_CP
5602 if test -n "$CP"; then
5603   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5604 $as_echo "$CP" >&6; }
5605 else
5606   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5607 $as_echo "no" >&6; }
5608 fi
5609 
5610 
5611   test -n "$CP" && break
5612 done
5613 
5614   else
5615     # The variable is set, but is it from the command line or the environment?
5616 
5617     # Try to remove the string !CP! from our list.
5618     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CP!/}
5619     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5620       # If it failed, the variable was not from the command line. Ignore it,
5621       # but warn the user (except for BASH, which is always set by the calling BASH).
5622       if test "xCP" != xBASH; then
5623         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
5624 $as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
5625       fi
5626       # Try to locate tool using the code snippet
5627       for ac_prog in cp
5628 do
5629   # Extract the first word of "$ac_prog", so it can be a program name with args.
5630 set dummy $ac_prog; ac_word=$2
5631 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5632 $as_echo_n "checking for $ac_word... " >&6; }
5633 if ${ac_cv_path_CP+:} false; then :
5634   $as_echo_n "(cached) " >&6
5635 else
5636   case $CP in
5637   [\\/]* | ?:[\\/]*)
5638   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5639   ;;
5640   *)
5641   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5642 for as_dir in $PATH
5643 do
5644   IFS=$as_save_IFS
5645   test -z "$as_dir" && as_dir=.
5646     for ac_exec_ext in '' $ac_executable_extensions; do
5647   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5648     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5649     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5650     break 2
5651   fi
5652 done
5653   done
5654 IFS=$as_save_IFS
5655 
5656   ;;
5657 esac
5658 fi
5659 CP=$ac_cv_path_CP
5660 if test -n "$CP"; then
5661   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5662 $as_echo "$CP" >&6; }
5663 else
5664   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5665 $as_echo "no" >&6; }
5666 fi
5667 
5668 
5669   test -n "$CP" && break
5670 done
5671 
5672     else
5673       # If it succeeded, then it was overridden by the user. We will use it
5674       # for the tool.
5675 
5676       # First remove it from the list of overridden variables, so we can test
5677       # for unknown variables in the end.
5678       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5679 
5680       # Check if the provided tool contains a complete path.
5681       tool_specified="$CP"
5682       tool_basename="${tool_specified##*/}"
5683       if test "x$tool_basename" = "x$tool_specified"; then
5684         # A command without a complete path is provided, search $PATH.
5685         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
5686 $as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
5687         # Extract the first word of "$tool_basename", so it can be a program name with args.
5688 set dummy $tool_basename; ac_word=$2
5689 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5690 $as_echo_n "checking for $ac_word... " >&6; }
5691 if ${ac_cv_path_CP+:} false; then :
5692   $as_echo_n "(cached) " >&6
5693 else
5694   case $CP in
5695   [\\/]* | ?:[\\/]*)
5696   ac_cv_path_CP="$CP" # Let the user override the test with a path.
5697   ;;
5698   *)
5699   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5700 for as_dir in $PATH
5701 do
5702   IFS=$as_save_IFS
5703   test -z "$as_dir" && as_dir=.
5704     for ac_exec_ext in '' $ac_executable_extensions; do
5705   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5706     ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
5707     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5708     break 2
5709   fi
5710 done
5711   done
5712 IFS=$as_save_IFS
5713 
5714   ;;
5715 esac
5716 fi
5717 CP=$ac_cv_path_CP
5718 if test -n "$CP"; then
5719   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
5720 $as_echo "$CP" >&6; }
5721 else
5722   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5723 $as_echo "no" >&6; }
5724 fi
5725 
5726 
5727         if test "x$CP" = x; then
5728           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5729         fi
5730       else
5731         # Otherwise we believe it is a complete path. Use it as it is.
5732         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
5733 $as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
5734         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
5735 $as_echo_n "checking for CP... " >&6; }
5736         if test ! -x "$tool_specified"; then
5737           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5738 $as_echo "not found" >&6; }
5739           as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
5740         fi
5741         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5742 $as_echo "$tool_specified" >&6; }
5743       fi
5744     fi
5745   fi
5746 
5747 
5748 
5749   if test "x$CP" = x; then
5750     as_fn_error $? "Could not find required tool for CP" "$LINENO" 5
5751   fi
5752 
5753 
5754 
5755 
5756 
5757   # Publish this variable in the help.
5758 
5759 
5760   if test "x$CUT" = x; then
5761     # The variable is not set by user, try to locate tool using the code snippet
5762     for ac_prog in cut
5763 do
5764   # Extract the first word of "$ac_prog", so it can be a program name with args.
5765 set dummy $ac_prog; ac_word=$2
5766 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5767 $as_echo_n "checking for $ac_word... " >&6; }
5768 if ${ac_cv_path_CUT+:} false; then :
5769   $as_echo_n "(cached) " >&6
5770 else
5771   case $CUT in
5772   [\\/]* | ?:[\\/]*)
5773   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5774   ;;
5775   *)
5776   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5777 for as_dir in $PATH
5778 do
5779   IFS=$as_save_IFS
5780   test -z "$as_dir" && as_dir=.
5781     for ac_exec_ext in '' $ac_executable_extensions; do
5782   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5783     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5784     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5785     break 2
5786   fi
5787 done
5788   done
5789 IFS=$as_save_IFS
5790 
5791   ;;
5792 esac
5793 fi
5794 CUT=$ac_cv_path_CUT
5795 if test -n "$CUT"; then
5796   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5797 $as_echo "$CUT" >&6; }
5798 else
5799   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5800 $as_echo "no" >&6; }
5801 fi
5802 
5803 
5804   test -n "$CUT" && break
5805 done
5806 
5807   else
5808     # The variable is set, but is it from the command line or the environment?
5809 
5810     # Try to remove the string !CUT! from our list.
5811     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CUT!/}
5812     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
5813       # If it failed, the variable was not from the command line. Ignore it,
5814       # but warn the user (except for BASH, which is always set by the calling BASH).
5815       if test "xCUT" != xBASH; then
5816         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
5817 $as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
5818       fi
5819       # Try to locate tool using the code snippet
5820       for ac_prog in cut
5821 do
5822   # Extract the first word of "$ac_prog", so it can be a program name with args.
5823 set dummy $ac_prog; ac_word=$2
5824 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5825 $as_echo_n "checking for $ac_word... " >&6; }
5826 if ${ac_cv_path_CUT+:} false; then :
5827   $as_echo_n "(cached) " >&6
5828 else
5829   case $CUT in
5830   [\\/]* | ?:[\\/]*)
5831   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5832   ;;
5833   *)
5834   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5835 for as_dir in $PATH
5836 do
5837   IFS=$as_save_IFS
5838   test -z "$as_dir" && as_dir=.
5839     for ac_exec_ext in '' $ac_executable_extensions; do
5840   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5841     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5842     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5843     break 2
5844   fi
5845 done
5846   done
5847 IFS=$as_save_IFS
5848 
5849   ;;
5850 esac
5851 fi
5852 CUT=$ac_cv_path_CUT
5853 if test -n "$CUT"; then
5854   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5855 $as_echo "$CUT" >&6; }
5856 else
5857   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5858 $as_echo "no" >&6; }
5859 fi
5860 
5861 
5862   test -n "$CUT" && break
5863 done
5864 
5865     else
5866       # If it succeeded, then it was overridden by the user. We will use it
5867       # for the tool.
5868 
5869       # First remove it from the list of overridden variables, so we can test
5870       # for unknown variables in the end.
5871       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
5872 
5873       # Check if the provided tool contains a complete path.
5874       tool_specified="$CUT"
5875       tool_basename="${tool_specified##*/}"
5876       if test "x$tool_basename" = "x$tool_specified"; then
5877         # A command without a complete path is provided, search $PATH.
5878         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
5879 $as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
5880         # Extract the first word of "$tool_basename", so it can be a program name with args.
5881 set dummy $tool_basename; ac_word=$2
5882 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5883 $as_echo_n "checking for $ac_word... " >&6; }
5884 if ${ac_cv_path_CUT+:} false; then :
5885   $as_echo_n "(cached) " >&6
5886 else
5887   case $CUT in
5888   [\\/]* | ?:[\\/]*)
5889   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
5890   ;;
5891   *)
5892   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5893 for as_dir in $PATH
5894 do
5895   IFS=$as_save_IFS
5896   test -z "$as_dir" && as_dir=.
5897     for ac_exec_ext in '' $ac_executable_extensions; do
5898   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5899     ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
5900     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5901     break 2
5902   fi
5903 done
5904   done
5905 IFS=$as_save_IFS
5906 
5907   ;;
5908 esac
5909 fi
5910 CUT=$ac_cv_path_CUT
5911 if test -n "$CUT"; then
5912   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
5913 $as_echo "$CUT" >&6; }
5914 else
5915   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5916 $as_echo "no" >&6; }
5917 fi
5918 
5919 
5920         if test "x$CUT" = x; then
5921           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
5922         fi
5923       else
5924         # Otherwise we believe it is a complete path. Use it as it is.
5925         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
5926 $as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
5927         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
5928 $as_echo_n "checking for CUT... " >&6; }
5929         if test ! -x "$tool_specified"; then
5930           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5931 $as_echo "not found" >&6; }
5932           as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
5933         fi
5934         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
5935 $as_echo "$tool_specified" >&6; }
5936       fi
5937     fi
5938   fi
5939 
5940 
5941 
5942   if test "x$CUT" = x; then
5943     as_fn_error $? "Could not find required tool for CUT" "$LINENO" 5
5944   fi
5945 
5946 
5947 
5948 
5949 
5950   # Publish this variable in the help.
5951 
5952 
5953   if test "x$DATE" = x; then
5954     # The variable is not set by user, try to locate tool using the code snippet
5955     for ac_prog in date
5956 do
5957   # Extract the first word of "$ac_prog", so it can be a program name with args.
5958 set dummy $ac_prog; ac_word=$2
5959 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5960 $as_echo_n "checking for $ac_word... " >&6; }
5961 if ${ac_cv_path_DATE+:} false; then :
5962   $as_echo_n "(cached) " >&6
5963 else
5964   case $DATE in
5965   [\\/]* | ?:[\\/]*)
5966   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
5967   ;;
5968   *)
5969   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5970 for as_dir in $PATH
5971 do
5972   IFS=$as_save_IFS
5973   test -z "$as_dir" && as_dir=.
5974     for ac_exec_ext in '' $ac_executable_extensions; do
5975   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5976     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
5977     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5978     break 2
5979   fi
5980 done
5981   done
5982 IFS=$as_save_IFS
5983 
5984   ;;
5985 esac
5986 fi
5987 DATE=$ac_cv_path_DATE
5988 if test -n "$DATE"; then
5989   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
5990 $as_echo "$DATE" >&6; }
5991 else
5992   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5993 $as_echo "no" >&6; }
5994 fi
5995 
5996 
5997   test -n "$DATE" && break
5998 done
5999 
6000   else
6001     # The variable is set, but is it from the command line or the environment?
6002 
6003     # Try to remove the string !DATE! from our list.
6004     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DATE!/}
6005     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6006       # If it failed, the variable was not from the command line. Ignore it,
6007       # but warn the user (except for BASH, which is always set by the calling BASH).
6008       if test "xDATE" != xBASH; then
6009         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
6010 $as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
6011       fi
6012       # Try to locate tool using the code snippet
6013       for ac_prog in date
6014 do
6015   # Extract the first word of "$ac_prog", so it can be a program name with args.
6016 set dummy $ac_prog; ac_word=$2
6017 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6018 $as_echo_n "checking for $ac_word... " >&6; }
6019 if ${ac_cv_path_DATE+:} false; then :
6020   $as_echo_n "(cached) " >&6
6021 else
6022   case $DATE in
6023   [\\/]* | ?:[\\/]*)
6024   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6025   ;;
6026   *)
6027   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6028 for as_dir in $PATH
6029 do
6030   IFS=$as_save_IFS
6031   test -z "$as_dir" && as_dir=.
6032     for ac_exec_ext in '' $ac_executable_extensions; do
6033   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6034     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6035     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6036     break 2
6037   fi
6038 done
6039   done
6040 IFS=$as_save_IFS
6041 
6042   ;;
6043 esac
6044 fi
6045 DATE=$ac_cv_path_DATE
6046 if test -n "$DATE"; then
6047   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6048 $as_echo "$DATE" >&6; }
6049 else
6050   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6051 $as_echo "no" >&6; }
6052 fi
6053 
6054 
6055   test -n "$DATE" && break
6056 done
6057 
6058     else
6059       # If it succeeded, then it was overridden by the user. We will use it
6060       # for the tool.
6061 
6062       # First remove it from the list of overridden variables, so we can test
6063       # for unknown variables in the end.
6064       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6065 
6066       # Check if the provided tool contains a complete path.
6067       tool_specified="$DATE"
6068       tool_basename="${tool_specified##*/}"
6069       if test "x$tool_basename" = "x$tool_specified"; then
6070         # A command without a complete path is provided, search $PATH.
6071         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
6072 $as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
6073         # Extract the first word of "$tool_basename", so it can be a program name with args.
6074 set dummy $tool_basename; ac_word=$2
6075 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6076 $as_echo_n "checking for $ac_word... " >&6; }
6077 if ${ac_cv_path_DATE+:} false; then :
6078   $as_echo_n "(cached) " >&6
6079 else
6080   case $DATE in
6081   [\\/]* | ?:[\\/]*)
6082   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
6083   ;;
6084   *)
6085   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6086 for as_dir in $PATH
6087 do
6088   IFS=$as_save_IFS
6089   test -z "$as_dir" && as_dir=.
6090     for ac_exec_ext in '' $ac_executable_extensions; do
6091   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6092     ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
6093     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6094     break 2
6095   fi
6096 done
6097   done
6098 IFS=$as_save_IFS
6099 
6100   ;;
6101 esac
6102 fi
6103 DATE=$ac_cv_path_DATE
6104 if test -n "$DATE"; then
6105   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
6106 $as_echo "$DATE" >&6; }
6107 else
6108   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6109 $as_echo "no" >&6; }
6110 fi
6111 
6112 
6113         if test "x$DATE" = x; then
6114           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6115         fi
6116       else
6117         # Otherwise we believe it is a complete path. Use it as it is.
6118         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
6119 $as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
6120         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
6121 $as_echo_n "checking for DATE... " >&6; }
6122         if test ! -x "$tool_specified"; then
6123           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6124 $as_echo "not found" >&6; }
6125           as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
6126         fi
6127         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6128 $as_echo "$tool_specified" >&6; }
6129       fi
6130     fi
6131   fi
6132 
6133 
6134 
6135   if test "x$DATE" = x; then
6136     as_fn_error $? "Could not find required tool for DATE" "$LINENO" 5
6137   fi
6138 
6139 
6140 
6141 
6142 
6143   # Publish this variable in the help.
6144 
6145 
6146   if test "x$DIFF" = x; then
6147     # The variable is not set by user, try to locate tool using the code snippet
6148     for ac_prog in gdiff diff
6149 do
6150   # Extract the first word of "$ac_prog", so it can be a program name with args.
6151 set dummy $ac_prog; ac_word=$2
6152 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6153 $as_echo_n "checking for $ac_word... " >&6; }
6154 if ${ac_cv_path_DIFF+:} false; then :
6155   $as_echo_n "(cached) " >&6
6156 else
6157   case $DIFF in
6158   [\\/]* | ?:[\\/]*)
6159   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6160   ;;
6161   *)
6162   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6163 for as_dir in $PATH
6164 do
6165   IFS=$as_save_IFS
6166   test -z "$as_dir" && as_dir=.
6167     for ac_exec_ext in '' $ac_executable_extensions; do
6168   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6169     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6170     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6171     break 2
6172   fi
6173 done
6174   done
6175 IFS=$as_save_IFS
6176 
6177   ;;
6178 esac
6179 fi
6180 DIFF=$ac_cv_path_DIFF
6181 if test -n "$DIFF"; then
6182   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6183 $as_echo "$DIFF" >&6; }
6184 else
6185   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6186 $as_echo "no" >&6; }
6187 fi
6188 
6189 
6190   test -n "$DIFF" && break
6191 done
6192 
6193   else
6194     # The variable is set, but is it from the command line or the environment?
6195 
6196     # Try to remove the string !DIFF! from our list.
6197     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIFF!/}
6198     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6199       # If it failed, the variable was not from the command line. Ignore it,
6200       # but warn the user (except for BASH, which is always set by the calling BASH).
6201       if test "xDIFF" != xBASH; then
6202         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
6203 $as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
6204       fi
6205       # Try to locate tool using the code snippet
6206       for ac_prog in gdiff diff
6207 do
6208   # Extract the first word of "$ac_prog", so it can be a program name with args.
6209 set dummy $ac_prog; ac_word=$2
6210 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6211 $as_echo_n "checking for $ac_word... " >&6; }
6212 if ${ac_cv_path_DIFF+:} false; then :
6213   $as_echo_n "(cached) " >&6
6214 else
6215   case $DIFF in
6216   [\\/]* | ?:[\\/]*)
6217   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6218   ;;
6219   *)
6220   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6221 for as_dir in $PATH
6222 do
6223   IFS=$as_save_IFS
6224   test -z "$as_dir" && as_dir=.
6225     for ac_exec_ext in '' $ac_executable_extensions; do
6226   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6227     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6228     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6229     break 2
6230   fi
6231 done
6232   done
6233 IFS=$as_save_IFS
6234 
6235   ;;
6236 esac
6237 fi
6238 DIFF=$ac_cv_path_DIFF
6239 if test -n "$DIFF"; then
6240   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6241 $as_echo "$DIFF" >&6; }
6242 else
6243   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6244 $as_echo "no" >&6; }
6245 fi
6246 
6247 
6248   test -n "$DIFF" && break
6249 done
6250 
6251     else
6252       # If it succeeded, then it was overridden by the user. We will use it
6253       # for the tool.
6254 
6255       # First remove it from the list of overridden variables, so we can test
6256       # for unknown variables in the end.
6257       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6258 
6259       # Check if the provided tool contains a complete path.
6260       tool_specified="$DIFF"
6261       tool_basename="${tool_specified##*/}"
6262       if test "x$tool_basename" = "x$tool_specified"; then
6263         # A command without a complete path is provided, search $PATH.
6264         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
6265 $as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
6266         # Extract the first word of "$tool_basename", so it can be a program name with args.
6267 set dummy $tool_basename; ac_word=$2
6268 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6269 $as_echo_n "checking for $ac_word... " >&6; }
6270 if ${ac_cv_path_DIFF+:} false; then :
6271   $as_echo_n "(cached) " >&6
6272 else
6273   case $DIFF in
6274   [\\/]* | ?:[\\/]*)
6275   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
6276   ;;
6277   *)
6278   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6279 for as_dir in $PATH
6280 do
6281   IFS=$as_save_IFS
6282   test -z "$as_dir" && as_dir=.
6283     for ac_exec_ext in '' $ac_executable_extensions; do
6284   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6285     ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
6286     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6287     break 2
6288   fi
6289 done
6290   done
6291 IFS=$as_save_IFS
6292 
6293   ;;
6294 esac
6295 fi
6296 DIFF=$ac_cv_path_DIFF
6297 if test -n "$DIFF"; then
6298   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
6299 $as_echo "$DIFF" >&6; }
6300 else
6301   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6302 $as_echo "no" >&6; }
6303 fi
6304 
6305 
6306         if test "x$DIFF" = x; then
6307           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6308         fi
6309       else
6310         # Otherwise we believe it is a complete path. Use it as it is.
6311         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
6312 $as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
6313         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
6314 $as_echo_n "checking for DIFF... " >&6; }
6315         if test ! -x "$tool_specified"; then
6316           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6317 $as_echo "not found" >&6; }
6318           as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
6319         fi
6320         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6321 $as_echo "$tool_specified" >&6; }
6322       fi
6323     fi
6324   fi
6325 
6326 
6327 
6328   if test "x$DIFF" = x; then
6329     as_fn_error $? "Could not find required tool for DIFF" "$LINENO" 5
6330   fi
6331 
6332 
6333 
6334 
6335 
6336   # Publish this variable in the help.
6337 
6338 
6339   if test "x$DIRNAME" = x; then
6340     # The variable is not set by user, try to locate tool using the code snippet
6341     for ac_prog in dirname
6342 do
6343   # Extract the first word of "$ac_prog", so it can be a program name with args.
6344 set dummy $ac_prog; ac_word=$2
6345 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6346 $as_echo_n "checking for $ac_word... " >&6; }
6347 if ${ac_cv_path_DIRNAME+:} false; then :
6348   $as_echo_n "(cached) " >&6
6349 else
6350   case $DIRNAME in
6351   [\\/]* | ?:[\\/]*)
6352   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6353   ;;
6354   *)
6355   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6356 for as_dir in $PATH
6357 do
6358   IFS=$as_save_IFS
6359   test -z "$as_dir" && as_dir=.
6360     for ac_exec_ext in '' $ac_executable_extensions; do
6361   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6362     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6363     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6364     break 2
6365   fi
6366 done
6367   done
6368 IFS=$as_save_IFS
6369 
6370   ;;
6371 esac
6372 fi
6373 DIRNAME=$ac_cv_path_DIRNAME
6374 if test -n "$DIRNAME"; then
6375   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6376 $as_echo "$DIRNAME" >&6; }
6377 else
6378   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6379 $as_echo "no" >&6; }
6380 fi
6381 
6382 
6383   test -n "$DIRNAME" && break
6384 done
6385 
6386   else
6387     # The variable is set, but is it from the command line or the environment?
6388 
6389     # Try to remove the string !DIRNAME! from our list.
6390     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DIRNAME!/}
6391     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6392       # If it failed, the variable was not from the command line. Ignore it,
6393       # but warn the user (except for BASH, which is always set by the calling BASH).
6394       if test "xDIRNAME" != xBASH; then
6395         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
6396 $as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
6397       fi
6398       # Try to locate tool using the code snippet
6399       for ac_prog in dirname
6400 do
6401   # Extract the first word of "$ac_prog", so it can be a program name with args.
6402 set dummy $ac_prog; ac_word=$2
6403 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6404 $as_echo_n "checking for $ac_word... " >&6; }
6405 if ${ac_cv_path_DIRNAME+:} false; then :
6406   $as_echo_n "(cached) " >&6
6407 else
6408   case $DIRNAME in
6409   [\\/]* | ?:[\\/]*)
6410   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6411   ;;
6412   *)
6413   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6414 for as_dir in $PATH
6415 do
6416   IFS=$as_save_IFS
6417   test -z "$as_dir" && as_dir=.
6418     for ac_exec_ext in '' $ac_executable_extensions; do
6419   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6420     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6421     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6422     break 2
6423   fi
6424 done
6425   done
6426 IFS=$as_save_IFS
6427 
6428   ;;
6429 esac
6430 fi
6431 DIRNAME=$ac_cv_path_DIRNAME
6432 if test -n "$DIRNAME"; then
6433   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6434 $as_echo "$DIRNAME" >&6; }
6435 else
6436   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6437 $as_echo "no" >&6; }
6438 fi
6439 
6440 
6441   test -n "$DIRNAME" && break
6442 done
6443 
6444     else
6445       # If it succeeded, then it was overridden by the user. We will use it
6446       # for the tool.
6447 
6448       # First remove it from the list of overridden variables, so we can test
6449       # for unknown variables in the end.
6450       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6451 
6452       # Check if the provided tool contains a complete path.
6453       tool_specified="$DIRNAME"
6454       tool_basename="${tool_specified##*/}"
6455       if test "x$tool_basename" = "x$tool_specified"; then
6456         # A command without a complete path is provided, search $PATH.
6457         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
6458 $as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
6459         # Extract the first word of "$tool_basename", so it can be a program name with args.
6460 set dummy $tool_basename; ac_word=$2
6461 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6462 $as_echo_n "checking for $ac_word... " >&6; }
6463 if ${ac_cv_path_DIRNAME+:} false; then :
6464   $as_echo_n "(cached) " >&6
6465 else
6466   case $DIRNAME in
6467   [\\/]* | ?:[\\/]*)
6468   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
6469   ;;
6470   *)
6471   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6472 for as_dir in $PATH
6473 do
6474   IFS=$as_save_IFS
6475   test -z "$as_dir" && as_dir=.
6476     for ac_exec_ext in '' $ac_executable_extensions; do
6477   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6478     ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
6479     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6480     break 2
6481   fi
6482 done
6483   done
6484 IFS=$as_save_IFS
6485 
6486   ;;
6487 esac
6488 fi
6489 DIRNAME=$ac_cv_path_DIRNAME
6490 if test -n "$DIRNAME"; then
6491   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
6492 $as_echo "$DIRNAME" >&6; }
6493 else
6494   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6495 $as_echo "no" >&6; }
6496 fi
6497 
6498 
6499         if test "x$DIRNAME" = x; then
6500           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6501         fi
6502       else
6503         # Otherwise we believe it is a complete path. Use it as it is.
6504         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
6505 $as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
6506         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
6507 $as_echo_n "checking for DIRNAME... " >&6; }
6508         if test ! -x "$tool_specified"; then
6509           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6510 $as_echo "not found" >&6; }
6511           as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
6512         fi
6513         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6514 $as_echo "$tool_specified" >&6; }
6515       fi
6516     fi
6517   fi
6518 
6519 
6520 
6521   if test "x$DIRNAME" = x; then
6522     as_fn_error $? "Could not find required tool for DIRNAME" "$LINENO" 5
6523   fi
6524 
6525 
6526 
6527 
6528 
6529   # Publish this variable in the help.
6530 
6531 
6532   if test "x$ECHO" = x; then
6533     # The variable is not set by user, try to locate tool using the code snippet
6534     for ac_prog in echo
6535 do
6536   # Extract the first word of "$ac_prog", so it can be a program name with args.
6537 set dummy $ac_prog; ac_word=$2
6538 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6539 $as_echo_n "checking for $ac_word... " >&6; }
6540 if ${ac_cv_path_ECHO+:} false; then :
6541   $as_echo_n "(cached) " >&6
6542 else
6543   case $ECHO in
6544   [\\/]* | ?:[\\/]*)
6545   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6546   ;;
6547   *)
6548   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6549 for as_dir in $PATH
6550 do
6551   IFS=$as_save_IFS
6552   test -z "$as_dir" && as_dir=.
6553     for ac_exec_ext in '' $ac_executable_extensions; do
6554   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6555     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6556     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6557     break 2
6558   fi
6559 done
6560   done
6561 IFS=$as_save_IFS
6562 
6563   ;;
6564 esac
6565 fi
6566 ECHO=$ac_cv_path_ECHO
6567 if test -n "$ECHO"; then
6568   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6569 $as_echo "$ECHO" >&6; }
6570 else
6571   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6572 $as_echo "no" >&6; }
6573 fi
6574 
6575 
6576   test -n "$ECHO" && break
6577 done
6578 
6579   else
6580     # The variable is set, but is it from the command line or the environment?
6581 
6582     # Try to remove the string !ECHO! from our list.
6583     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ECHO!/}
6584     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6585       # If it failed, the variable was not from the command line. Ignore it,
6586       # but warn the user (except for BASH, which is always set by the calling BASH).
6587       if test "xECHO" != xBASH; then
6588         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
6589 $as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
6590       fi
6591       # Try to locate tool using the code snippet
6592       for ac_prog in echo
6593 do
6594   # Extract the first word of "$ac_prog", so it can be a program name with args.
6595 set dummy $ac_prog; ac_word=$2
6596 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6597 $as_echo_n "checking for $ac_word... " >&6; }
6598 if ${ac_cv_path_ECHO+:} false; then :
6599   $as_echo_n "(cached) " >&6
6600 else
6601   case $ECHO in
6602   [\\/]* | ?:[\\/]*)
6603   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6604   ;;
6605   *)
6606   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6607 for as_dir in $PATH
6608 do
6609   IFS=$as_save_IFS
6610   test -z "$as_dir" && as_dir=.
6611     for ac_exec_ext in '' $ac_executable_extensions; do
6612   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6613     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6614     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6615     break 2
6616   fi
6617 done
6618   done
6619 IFS=$as_save_IFS
6620 
6621   ;;
6622 esac
6623 fi
6624 ECHO=$ac_cv_path_ECHO
6625 if test -n "$ECHO"; then
6626   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6627 $as_echo "$ECHO" >&6; }
6628 else
6629   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6630 $as_echo "no" >&6; }
6631 fi
6632 
6633 
6634   test -n "$ECHO" && break
6635 done
6636 
6637     else
6638       # If it succeeded, then it was overridden by the user. We will use it
6639       # for the tool.
6640 
6641       # First remove it from the list of overridden variables, so we can test
6642       # for unknown variables in the end.
6643       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6644 
6645       # Check if the provided tool contains a complete path.
6646       tool_specified="$ECHO"
6647       tool_basename="${tool_specified##*/}"
6648       if test "x$tool_basename" = "x$tool_specified"; then
6649         # A command without a complete path is provided, search $PATH.
6650         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
6651 $as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
6652         # Extract the first word of "$tool_basename", so it can be a program name with args.
6653 set dummy $tool_basename; ac_word=$2
6654 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6655 $as_echo_n "checking for $ac_word... " >&6; }
6656 if ${ac_cv_path_ECHO+:} false; then :
6657   $as_echo_n "(cached) " >&6
6658 else
6659   case $ECHO in
6660   [\\/]* | ?:[\\/]*)
6661   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
6662   ;;
6663   *)
6664   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6665 for as_dir in $PATH
6666 do
6667   IFS=$as_save_IFS
6668   test -z "$as_dir" && as_dir=.
6669     for ac_exec_ext in '' $ac_executable_extensions; do
6670   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6671     ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
6672     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6673     break 2
6674   fi
6675 done
6676   done
6677 IFS=$as_save_IFS
6678 
6679   ;;
6680 esac
6681 fi
6682 ECHO=$ac_cv_path_ECHO
6683 if test -n "$ECHO"; then
6684   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
6685 $as_echo "$ECHO" >&6; }
6686 else
6687   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6688 $as_echo "no" >&6; }
6689 fi
6690 
6691 
6692         if test "x$ECHO" = x; then
6693           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6694         fi
6695       else
6696         # Otherwise we believe it is a complete path. Use it as it is.
6697         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
6698 $as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
6699         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
6700 $as_echo_n "checking for ECHO... " >&6; }
6701         if test ! -x "$tool_specified"; then
6702           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6703 $as_echo "not found" >&6; }
6704           as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
6705         fi
6706         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6707 $as_echo "$tool_specified" >&6; }
6708       fi
6709     fi
6710   fi
6711 
6712 
6713 
6714   if test "x$ECHO" = x; then
6715     as_fn_error $? "Could not find required tool for ECHO" "$LINENO" 5
6716   fi
6717 
6718 
6719 
6720 
6721 
6722   # Publish this variable in the help.
6723 
6724 
6725   if test "x$EXPR" = x; then
6726     # The variable is not set by user, try to locate tool using the code snippet
6727     for ac_prog in expr
6728 do
6729   # Extract the first word of "$ac_prog", so it can be a program name with args.
6730 set dummy $ac_prog; ac_word=$2
6731 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6732 $as_echo_n "checking for $ac_word... " >&6; }
6733 if ${ac_cv_path_EXPR+:} false; then :
6734   $as_echo_n "(cached) " >&6
6735 else
6736   case $EXPR in
6737   [\\/]* | ?:[\\/]*)
6738   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6739   ;;
6740   *)
6741   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6742 for as_dir in $PATH
6743 do
6744   IFS=$as_save_IFS
6745   test -z "$as_dir" && as_dir=.
6746     for ac_exec_ext in '' $ac_executable_extensions; do
6747   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6748     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6749     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6750     break 2
6751   fi
6752 done
6753   done
6754 IFS=$as_save_IFS
6755 
6756   ;;
6757 esac
6758 fi
6759 EXPR=$ac_cv_path_EXPR
6760 if test -n "$EXPR"; then
6761   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6762 $as_echo "$EXPR" >&6; }
6763 else
6764   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6765 $as_echo "no" >&6; }
6766 fi
6767 
6768 
6769   test -n "$EXPR" && break
6770 done
6771 
6772   else
6773     # The variable is set, but is it from the command line or the environment?
6774 
6775     # Try to remove the string !EXPR! from our list.
6776     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EXPR!/}
6777     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6778       # If it failed, the variable was not from the command line. Ignore it,
6779       # but warn the user (except for BASH, which is always set by the calling BASH).
6780       if test "xEXPR" != xBASH; then
6781         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
6782 $as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
6783       fi
6784       # Try to locate tool using the code snippet
6785       for ac_prog in expr
6786 do
6787   # Extract the first word of "$ac_prog", so it can be a program name with args.
6788 set dummy $ac_prog; ac_word=$2
6789 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6790 $as_echo_n "checking for $ac_word... " >&6; }
6791 if ${ac_cv_path_EXPR+:} false; then :
6792   $as_echo_n "(cached) " >&6
6793 else
6794   case $EXPR in
6795   [\\/]* | ?:[\\/]*)
6796   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6797   ;;
6798   *)
6799   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6800 for as_dir in $PATH
6801 do
6802   IFS=$as_save_IFS
6803   test -z "$as_dir" && as_dir=.
6804     for ac_exec_ext in '' $ac_executable_extensions; do
6805   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6806     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6807     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6808     break 2
6809   fi
6810 done
6811   done
6812 IFS=$as_save_IFS
6813 
6814   ;;
6815 esac
6816 fi
6817 EXPR=$ac_cv_path_EXPR
6818 if test -n "$EXPR"; then
6819   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6820 $as_echo "$EXPR" >&6; }
6821 else
6822   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6823 $as_echo "no" >&6; }
6824 fi
6825 
6826 
6827   test -n "$EXPR" && break
6828 done
6829 
6830     else
6831       # If it succeeded, then it was overridden by the user. We will use it
6832       # for the tool.
6833 
6834       # First remove it from the list of overridden variables, so we can test
6835       # for unknown variables in the end.
6836       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
6837 
6838       # Check if the provided tool contains a complete path.
6839       tool_specified="$EXPR"
6840       tool_basename="${tool_specified##*/}"
6841       if test "x$tool_basename" = "x$tool_specified"; then
6842         # A command without a complete path is provided, search $PATH.
6843         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
6844 $as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
6845         # Extract the first word of "$tool_basename", so it can be a program name with args.
6846 set dummy $tool_basename; ac_word=$2
6847 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6848 $as_echo_n "checking for $ac_word... " >&6; }
6849 if ${ac_cv_path_EXPR+:} false; then :
6850   $as_echo_n "(cached) " >&6
6851 else
6852   case $EXPR in
6853   [\\/]* | ?:[\\/]*)
6854   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
6855   ;;
6856   *)
6857   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6858 for as_dir in $PATH
6859 do
6860   IFS=$as_save_IFS
6861   test -z "$as_dir" && as_dir=.
6862     for ac_exec_ext in '' $ac_executable_extensions; do
6863   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6864     ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
6865     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6866     break 2
6867   fi
6868 done
6869   done
6870 IFS=$as_save_IFS
6871 
6872   ;;
6873 esac
6874 fi
6875 EXPR=$ac_cv_path_EXPR
6876 if test -n "$EXPR"; then
6877   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
6878 $as_echo "$EXPR" >&6; }
6879 else
6880   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6881 $as_echo "no" >&6; }
6882 fi
6883 
6884 
6885         if test "x$EXPR" = x; then
6886           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
6887         fi
6888       else
6889         # Otherwise we believe it is a complete path. Use it as it is.
6890         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
6891 $as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
6892         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
6893 $as_echo_n "checking for EXPR... " >&6; }
6894         if test ! -x "$tool_specified"; then
6895           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6896 $as_echo "not found" >&6; }
6897           as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
6898         fi
6899         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
6900 $as_echo "$tool_specified" >&6; }
6901       fi
6902     fi
6903   fi
6904 
6905 
6906 
6907   if test "x$EXPR" = x; then
6908     as_fn_error $? "Could not find required tool for EXPR" "$LINENO" 5
6909   fi
6910 
6911 
6912 
6913 
6914 
6915   # Publish this variable in the help.
6916 
6917 
6918   if test "x$FILE" = x; then
6919     # The variable is not set by user, try to locate tool using the code snippet
6920     for ac_prog in file
6921 do
6922   # Extract the first word of "$ac_prog", so it can be a program name with args.
6923 set dummy $ac_prog; ac_word=$2
6924 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6925 $as_echo_n "checking for $ac_word... " >&6; }
6926 if ${ac_cv_path_FILE+:} false; then :
6927   $as_echo_n "(cached) " >&6
6928 else
6929   case $FILE in
6930   [\\/]* | ?:[\\/]*)
6931   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
6932   ;;
6933   *)
6934   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6935 for as_dir in $PATH
6936 do
6937   IFS=$as_save_IFS
6938   test -z "$as_dir" && as_dir=.
6939     for ac_exec_ext in '' $ac_executable_extensions; do
6940   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6941     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
6942     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6943     break 2
6944   fi
6945 done
6946   done
6947 IFS=$as_save_IFS
6948 
6949   ;;
6950 esac
6951 fi
6952 FILE=$ac_cv_path_FILE
6953 if test -n "$FILE"; then
6954   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
6955 $as_echo "$FILE" >&6; }
6956 else
6957   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6958 $as_echo "no" >&6; }
6959 fi
6960 
6961 
6962   test -n "$FILE" && break
6963 done
6964 
6965   else
6966     # The variable is set, but is it from the command line or the environment?
6967 
6968     # Try to remove the string !FILE! from our list.
6969     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FILE!/}
6970     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
6971       # If it failed, the variable was not from the command line. Ignore it,
6972       # but warn the user (except for BASH, which is always set by the calling BASH).
6973       if test "xFILE" != xBASH; then
6974         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
6975 $as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
6976       fi
6977       # Try to locate tool using the code snippet
6978       for ac_prog in file
6979 do
6980   # Extract the first word of "$ac_prog", so it can be a program name with args.
6981 set dummy $ac_prog; ac_word=$2
6982 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6983 $as_echo_n "checking for $ac_word... " >&6; }
6984 if ${ac_cv_path_FILE+:} false; then :
6985   $as_echo_n "(cached) " >&6
6986 else
6987   case $FILE in
6988   [\\/]* | ?:[\\/]*)
6989   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
6990   ;;
6991   *)
6992   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6993 for as_dir in $PATH
6994 do
6995   IFS=$as_save_IFS
6996   test -z "$as_dir" && as_dir=.
6997     for ac_exec_ext in '' $ac_executable_extensions; do
6998   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6999     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7000     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7001     break 2
7002   fi
7003 done
7004   done
7005 IFS=$as_save_IFS
7006 
7007   ;;
7008 esac
7009 fi
7010 FILE=$ac_cv_path_FILE
7011 if test -n "$FILE"; then
7012   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7013 $as_echo "$FILE" >&6; }
7014 else
7015   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7016 $as_echo "no" >&6; }
7017 fi
7018 
7019 
7020   test -n "$FILE" && break
7021 done
7022 
7023     else
7024       # If it succeeded, then it was overridden by the user. We will use it
7025       # for the tool.
7026 
7027       # First remove it from the list of overridden variables, so we can test
7028       # for unknown variables in the end.
7029       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7030 
7031       # Check if the provided tool contains a complete path.
7032       tool_specified="$FILE"
7033       tool_basename="${tool_specified##*/}"
7034       if test "x$tool_basename" = "x$tool_specified"; then
7035         # A command without a complete path is provided, search $PATH.
7036         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
7037 $as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
7038         # Extract the first word of "$tool_basename", so it can be a program name with args.
7039 set dummy $tool_basename; ac_word=$2
7040 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7041 $as_echo_n "checking for $ac_word... " >&6; }
7042 if ${ac_cv_path_FILE+:} false; then :
7043   $as_echo_n "(cached) " >&6
7044 else
7045   case $FILE in
7046   [\\/]* | ?:[\\/]*)
7047   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
7048   ;;
7049   *)
7050   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7051 for as_dir in $PATH
7052 do
7053   IFS=$as_save_IFS
7054   test -z "$as_dir" && as_dir=.
7055     for ac_exec_ext in '' $ac_executable_extensions; do
7056   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7057     ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
7058     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7059     break 2
7060   fi
7061 done
7062   done
7063 IFS=$as_save_IFS
7064 
7065   ;;
7066 esac
7067 fi
7068 FILE=$ac_cv_path_FILE
7069 if test -n "$FILE"; then
7070   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
7071 $as_echo "$FILE" >&6; }
7072 else
7073   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7074 $as_echo "no" >&6; }
7075 fi
7076 
7077 
7078         if test "x$FILE" = x; then
7079           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7080         fi
7081       else
7082         # Otherwise we believe it is a complete path. Use it as it is.
7083         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
7084 $as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
7085         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
7086 $as_echo_n "checking for FILE... " >&6; }
7087         if test ! -x "$tool_specified"; then
7088           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7089 $as_echo "not found" >&6; }
7090           as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
7091         fi
7092         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7093 $as_echo "$tool_specified" >&6; }
7094       fi
7095     fi
7096   fi
7097 
7098 
7099 
7100   if test "x$FILE" = x; then
7101     as_fn_error $? "Could not find required tool for FILE" "$LINENO" 5
7102   fi
7103 
7104 
7105 
7106 
7107 
7108   # Publish this variable in the help.
7109 
7110 
7111   if test "x$FIND" = x; then
7112     # The variable is not set by user, try to locate tool using the code snippet
7113     for ac_prog in find
7114 do
7115   # Extract the first word of "$ac_prog", so it can be a program name with args.
7116 set dummy $ac_prog; ac_word=$2
7117 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7118 $as_echo_n "checking for $ac_word... " >&6; }
7119 if ${ac_cv_path_FIND+:} false; then :
7120   $as_echo_n "(cached) " >&6
7121 else
7122   case $FIND in
7123   [\\/]* | ?:[\\/]*)
7124   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7125   ;;
7126   *)
7127   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7128 for as_dir in $PATH
7129 do
7130   IFS=$as_save_IFS
7131   test -z "$as_dir" && as_dir=.
7132     for ac_exec_ext in '' $ac_executable_extensions; do
7133   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7134     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7135     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7136     break 2
7137   fi
7138 done
7139   done
7140 IFS=$as_save_IFS
7141 
7142   ;;
7143 esac
7144 fi
7145 FIND=$ac_cv_path_FIND
7146 if test -n "$FIND"; then
7147   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7148 $as_echo "$FIND" >&6; }
7149 else
7150   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7151 $as_echo "no" >&6; }
7152 fi
7153 
7154 
7155   test -n "$FIND" && break
7156 done
7157 
7158   else
7159     # The variable is set, but is it from the command line or the environment?
7160 
7161     # Try to remove the string !FIND! from our list.
7162     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FIND!/}
7163     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7164       # If it failed, the variable was not from the command line. Ignore it,
7165       # but warn the user (except for BASH, which is always set by the calling BASH).
7166       if test "xFIND" != xBASH; then
7167         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
7168 $as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
7169       fi
7170       # Try to locate tool using the code snippet
7171       for ac_prog in find
7172 do
7173   # Extract the first word of "$ac_prog", so it can be a program name with args.
7174 set dummy $ac_prog; ac_word=$2
7175 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7176 $as_echo_n "checking for $ac_word... " >&6; }
7177 if ${ac_cv_path_FIND+:} false; then :
7178   $as_echo_n "(cached) " >&6
7179 else
7180   case $FIND in
7181   [\\/]* | ?:[\\/]*)
7182   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7183   ;;
7184   *)
7185   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7186 for as_dir in $PATH
7187 do
7188   IFS=$as_save_IFS
7189   test -z "$as_dir" && as_dir=.
7190     for ac_exec_ext in '' $ac_executable_extensions; do
7191   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7192     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7193     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7194     break 2
7195   fi
7196 done
7197   done
7198 IFS=$as_save_IFS
7199 
7200   ;;
7201 esac
7202 fi
7203 FIND=$ac_cv_path_FIND
7204 if test -n "$FIND"; then
7205   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7206 $as_echo "$FIND" >&6; }
7207 else
7208   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7209 $as_echo "no" >&6; }
7210 fi
7211 
7212 
7213   test -n "$FIND" && break
7214 done
7215 
7216     else
7217       # If it succeeded, then it was overridden by the user. We will use it
7218       # for the tool.
7219 
7220       # First remove it from the list of overridden variables, so we can test
7221       # for unknown variables in the end.
7222       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7223 
7224       # Check if the provided tool contains a complete path.
7225       tool_specified="$FIND"
7226       tool_basename="${tool_specified##*/}"
7227       if test "x$tool_basename" = "x$tool_specified"; then
7228         # A command without a complete path is provided, search $PATH.
7229         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
7230 $as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
7231         # Extract the first word of "$tool_basename", so it can be a program name with args.
7232 set dummy $tool_basename; ac_word=$2
7233 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7234 $as_echo_n "checking for $ac_word... " >&6; }
7235 if ${ac_cv_path_FIND+:} false; then :
7236   $as_echo_n "(cached) " >&6
7237 else
7238   case $FIND in
7239   [\\/]* | ?:[\\/]*)
7240   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
7241   ;;
7242   *)
7243   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7244 for as_dir in $PATH
7245 do
7246   IFS=$as_save_IFS
7247   test -z "$as_dir" && as_dir=.
7248     for ac_exec_ext in '' $ac_executable_extensions; do
7249   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7250     ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
7251     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7252     break 2
7253   fi
7254 done
7255   done
7256 IFS=$as_save_IFS
7257 
7258   ;;
7259 esac
7260 fi
7261 FIND=$ac_cv_path_FIND
7262 if test -n "$FIND"; then
7263   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
7264 $as_echo "$FIND" >&6; }
7265 else
7266   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7267 $as_echo "no" >&6; }
7268 fi
7269 
7270 
7271         if test "x$FIND" = x; then
7272           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7273         fi
7274       else
7275         # Otherwise we believe it is a complete path. Use it as it is.
7276         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
7277 $as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
7278         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
7279 $as_echo_n "checking for FIND... " >&6; }
7280         if test ! -x "$tool_specified"; then
7281           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7282 $as_echo "not found" >&6; }
7283           as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
7284         fi
7285         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7286 $as_echo "$tool_specified" >&6; }
7287       fi
7288     fi
7289   fi
7290 
7291 
7292 
7293   if test "x$FIND" = x; then
7294     as_fn_error $? "Could not find required tool for FIND" "$LINENO" 5
7295   fi
7296 
7297 
7298 
7299 
7300 
7301   # Publish this variable in the help.
7302 
7303 
7304   if test "x$HEAD" = x; then
7305     # The variable is not set by user, try to locate tool using the code snippet
7306     for ac_prog in head
7307 do
7308   # Extract the first word of "$ac_prog", so it can be a program name with args.
7309 set dummy $ac_prog; ac_word=$2
7310 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7311 $as_echo_n "checking for $ac_word... " >&6; }
7312 if ${ac_cv_path_HEAD+:} false; then :
7313   $as_echo_n "(cached) " >&6
7314 else
7315   case $HEAD in
7316   [\\/]* | ?:[\\/]*)
7317   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7318   ;;
7319   *)
7320   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7321 for as_dir in $PATH
7322 do
7323   IFS=$as_save_IFS
7324   test -z "$as_dir" && as_dir=.
7325     for ac_exec_ext in '' $ac_executable_extensions; do
7326   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7327     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7328     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7329     break 2
7330   fi
7331 done
7332   done
7333 IFS=$as_save_IFS
7334 
7335   ;;
7336 esac
7337 fi
7338 HEAD=$ac_cv_path_HEAD
7339 if test -n "$HEAD"; then
7340   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7341 $as_echo "$HEAD" >&6; }
7342 else
7343   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7344 $as_echo "no" >&6; }
7345 fi
7346 
7347 
7348   test -n "$HEAD" && break
7349 done
7350 
7351   else
7352     # The variable is set, but is it from the command line or the environment?
7353 
7354     # Try to remove the string !HEAD! from our list.
7355     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HEAD!/}
7356     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7357       # If it failed, the variable was not from the command line. Ignore it,
7358       # but warn the user (except for BASH, which is always set by the calling BASH).
7359       if test "xHEAD" != xBASH; then
7360         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
7361 $as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
7362       fi
7363       # Try to locate tool using the code snippet
7364       for ac_prog in head
7365 do
7366   # Extract the first word of "$ac_prog", so it can be a program name with args.
7367 set dummy $ac_prog; ac_word=$2
7368 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7369 $as_echo_n "checking for $ac_word... " >&6; }
7370 if ${ac_cv_path_HEAD+:} false; then :
7371   $as_echo_n "(cached) " >&6
7372 else
7373   case $HEAD in
7374   [\\/]* | ?:[\\/]*)
7375   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7376   ;;
7377   *)
7378   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7379 for as_dir in $PATH
7380 do
7381   IFS=$as_save_IFS
7382   test -z "$as_dir" && as_dir=.
7383     for ac_exec_ext in '' $ac_executable_extensions; do
7384   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7385     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7386     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7387     break 2
7388   fi
7389 done
7390   done
7391 IFS=$as_save_IFS
7392 
7393   ;;
7394 esac
7395 fi
7396 HEAD=$ac_cv_path_HEAD
7397 if test -n "$HEAD"; then
7398   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7399 $as_echo "$HEAD" >&6; }
7400 else
7401   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7402 $as_echo "no" >&6; }
7403 fi
7404 
7405 
7406   test -n "$HEAD" && break
7407 done
7408 
7409     else
7410       # If it succeeded, then it was overridden by the user. We will use it
7411       # for the tool.
7412 
7413       # First remove it from the list of overridden variables, so we can test
7414       # for unknown variables in the end.
7415       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7416 
7417       # Check if the provided tool contains a complete path.
7418       tool_specified="$HEAD"
7419       tool_basename="${tool_specified##*/}"
7420       if test "x$tool_basename" = "x$tool_specified"; then
7421         # A command without a complete path is provided, search $PATH.
7422         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
7423 $as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
7424         # Extract the first word of "$tool_basename", so it can be a program name with args.
7425 set dummy $tool_basename; ac_word=$2
7426 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7427 $as_echo_n "checking for $ac_word... " >&6; }
7428 if ${ac_cv_path_HEAD+:} false; then :
7429   $as_echo_n "(cached) " >&6
7430 else
7431   case $HEAD in
7432   [\\/]* | ?:[\\/]*)
7433   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
7434   ;;
7435   *)
7436   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7437 for as_dir in $PATH
7438 do
7439   IFS=$as_save_IFS
7440   test -z "$as_dir" && as_dir=.
7441     for ac_exec_ext in '' $ac_executable_extensions; do
7442   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7443     ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
7444     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7445     break 2
7446   fi
7447 done
7448   done
7449 IFS=$as_save_IFS
7450 
7451   ;;
7452 esac
7453 fi
7454 HEAD=$ac_cv_path_HEAD
7455 if test -n "$HEAD"; then
7456   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
7457 $as_echo "$HEAD" >&6; }
7458 else
7459   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7460 $as_echo "no" >&6; }
7461 fi
7462 
7463 
7464         if test "x$HEAD" = x; then
7465           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7466         fi
7467       else
7468         # Otherwise we believe it is a complete path. Use it as it is.
7469         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
7470 $as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
7471         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
7472 $as_echo_n "checking for HEAD... " >&6; }
7473         if test ! -x "$tool_specified"; then
7474           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7475 $as_echo "not found" >&6; }
7476           as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
7477         fi
7478         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7479 $as_echo "$tool_specified" >&6; }
7480       fi
7481     fi
7482   fi
7483 
7484 
7485 
7486   if test "x$HEAD" = x; then
7487     as_fn_error $? "Could not find required tool for HEAD" "$LINENO" 5
7488   fi
7489 
7490 
7491 
7492 
7493 
7494   # Publish this variable in the help.
7495 
7496 
7497   if test "x$LN" = x; then
7498     # The variable is not set by user, try to locate tool using the code snippet
7499     for ac_prog in ln
7500 do
7501   # Extract the first word of "$ac_prog", so it can be a program name with args.
7502 set dummy $ac_prog; ac_word=$2
7503 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7504 $as_echo_n "checking for $ac_word... " >&6; }
7505 if ${ac_cv_path_LN+:} false; then :
7506   $as_echo_n "(cached) " >&6
7507 else
7508   case $LN in
7509   [\\/]* | ?:[\\/]*)
7510   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7511   ;;
7512   *)
7513   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7514 for as_dir in $PATH
7515 do
7516   IFS=$as_save_IFS
7517   test -z "$as_dir" && as_dir=.
7518     for ac_exec_ext in '' $ac_executable_extensions; do
7519   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7520     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7521     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7522     break 2
7523   fi
7524 done
7525   done
7526 IFS=$as_save_IFS
7527 
7528   ;;
7529 esac
7530 fi
7531 LN=$ac_cv_path_LN
7532 if test -n "$LN"; then
7533   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7534 $as_echo "$LN" >&6; }
7535 else
7536   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7537 $as_echo "no" >&6; }
7538 fi
7539 
7540 
7541   test -n "$LN" && break
7542 done
7543 
7544   else
7545     # The variable is set, but is it from the command line or the environment?
7546 
7547     # Try to remove the string !LN! from our list.
7548     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LN!/}
7549     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7550       # If it failed, the variable was not from the command line. Ignore it,
7551       # but warn the user (except for BASH, which is always set by the calling BASH).
7552       if test "xLN" != xBASH; then
7553         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
7554 $as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
7555       fi
7556       # Try to locate tool using the code snippet
7557       for ac_prog in ln
7558 do
7559   # Extract the first word of "$ac_prog", so it can be a program name with args.
7560 set dummy $ac_prog; ac_word=$2
7561 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7562 $as_echo_n "checking for $ac_word... " >&6; }
7563 if ${ac_cv_path_LN+:} false; then :
7564   $as_echo_n "(cached) " >&6
7565 else
7566   case $LN in
7567   [\\/]* | ?:[\\/]*)
7568   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7569   ;;
7570   *)
7571   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7572 for as_dir in $PATH
7573 do
7574   IFS=$as_save_IFS
7575   test -z "$as_dir" && as_dir=.
7576     for ac_exec_ext in '' $ac_executable_extensions; do
7577   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7578     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7579     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7580     break 2
7581   fi
7582 done
7583   done
7584 IFS=$as_save_IFS
7585 
7586   ;;
7587 esac
7588 fi
7589 LN=$ac_cv_path_LN
7590 if test -n "$LN"; then
7591   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7592 $as_echo "$LN" >&6; }
7593 else
7594   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7595 $as_echo "no" >&6; }
7596 fi
7597 
7598 
7599   test -n "$LN" && break
7600 done
7601 
7602     else
7603       # If it succeeded, then it was overridden by the user. We will use it
7604       # for the tool.
7605 
7606       # First remove it from the list of overridden variables, so we can test
7607       # for unknown variables in the end.
7608       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7609 
7610       # Check if the provided tool contains a complete path.
7611       tool_specified="$LN"
7612       tool_basename="${tool_specified##*/}"
7613       if test "x$tool_basename" = "x$tool_specified"; then
7614         # A command without a complete path is provided, search $PATH.
7615         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
7616 $as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
7617         # Extract the first word of "$tool_basename", so it can be a program name with args.
7618 set dummy $tool_basename; ac_word=$2
7619 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7620 $as_echo_n "checking for $ac_word... " >&6; }
7621 if ${ac_cv_path_LN+:} false; then :
7622   $as_echo_n "(cached) " >&6
7623 else
7624   case $LN in
7625   [\\/]* | ?:[\\/]*)
7626   ac_cv_path_LN="$LN" # Let the user override the test with a path.
7627   ;;
7628   *)
7629   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7630 for as_dir in $PATH
7631 do
7632   IFS=$as_save_IFS
7633   test -z "$as_dir" && as_dir=.
7634     for ac_exec_ext in '' $ac_executable_extensions; do
7635   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7636     ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
7637     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7638     break 2
7639   fi
7640 done
7641   done
7642 IFS=$as_save_IFS
7643 
7644   ;;
7645 esac
7646 fi
7647 LN=$ac_cv_path_LN
7648 if test -n "$LN"; then
7649   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
7650 $as_echo "$LN" >&6; }
7651 else
7652   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7653 $as_echo "no" >&6; }
7654 fi
7655 
7656 
7657         if test "x$LN" = x; then
7658           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7659         fi
7660       else
7661         # Otherwise we believe it is a complete path. Use it as it is.
7662         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
7663 $as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
7664         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
7665 $as_echo_n "checking for LN... " >&6; }
7666         if test ! -x "$tool_specified"; then
7667           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7668 $as_echo "not found" >&6; }
7669           as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
7670         fi
7671         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7672 $as_echo "$tool_specified" >&6; }
7673       fi
7674     fi
7675   fi
7676 
7677 
7678 
7679   if test "x$LN" = x; then
7680     as_fn_error $? "Could not find required tool for LN" "$LINENO" 5
7681   fi
7682 
7683 
7684 
7685 
7686 
7687   # Publish this variable in the help.
7688 
7689 
7690   if test "x$LS" = x; then
7691     # The variable is not set by user, try to locate tool using the code snippet
7692     for ac_prog in ls
7693 do
7694   # Extract the first word of "$ac_prog", so it can be a program name with args.
7695 set dummy $ac_prog; ac_word=$2
7696 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7697 $as_echo_n "checking for $ac_word... " >&6; }
7698 if ${ac_cv_path_LS+:} false; then :
7699   $as_echo_n "(cached) " >&6
7700 else
7701   case $LS in
7702   [\\/]* | ?:[\\/]*)
7703   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7704   ;;
7705   *)
7706   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7707 for as_dir in $PATH
7708 do
7709   IFS=$as_save_IFS
7710   test -z "$as_dir" && as_dir=.
7711     for ac_exec_ext in '' $ac_executable_extensions; do
7712   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7713     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7714     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7715     break 2
7716   fi
7717 done
7718   done
7719 IFS=$as_save_IFS
7720 
7721   ;;
7722 esac
7723 fi
7724 LS=$ac_cv_path_LS
7725 if test -n "$LS"; then
7726   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7727 $as_echo "$LS" >&6; }
7728 else
7729   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7730 $as_echo "no" >&6; }
7731 fi
7732 
7733 
7734   test -n "$LS" && break
7735 done
7736 
7737   else
7738     # The variable is set, but is it from the command line or the environment?
7739 
7740     # Try to remove the string !LS! from our list.
7741     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LS!/}
7742     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7743       # If it failed, the variable was not from the command line. Ignore it,
7744       # but warn the user (except for BASH, which is always set by the calling BASH).
7745       if test "xLS" != xBASH; then
7746         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
7747 $as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
7748       fi
7749       # Try to locate tool using the code snippet
7750       for ac_prog in ls
7751 do
7752   # Extract the first word of "$ac_prog", so it can be a program name with args.
7753 set dummy $ac_prog; ac_word=$2
7754 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7755 $as_echo_n "checking for $ac_word... " >&6; }
7756 if ${ac_cv_path_LS+:} false; then :
7757   $as_echo_n "(cached) " >&6
7758 else
7759   case $LS in
7760   [\\/]* | ?:[\\/]*)
7761   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7762   ;;
7763   *)
7764   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7765 for as_dir in $PATH
7766 do
7767   IFS=$as_save_IFS
7768   test -z "$as_dir" && as_dir=.
7769     for ac_exec_ext in '' $ac_executable_extensions; do
7770   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7771     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7772     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7773     break 2
7774   fi
7775 done
7776   done
7777 IFS=$as_save_IFS
7778 
7779   ;;
7780 esac
7781 fi
7782 LS=$ac_cv_path_LS
7783 if test -n "$LS"; then
7784   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7785 $as_echo "$LS" >&6; }
7786 else
7787   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7788 $as_echo "no" >&6; }
7789 fi
7790 
7791 
7792   test -n "$LS" && break
7793 done
7794 
7795     else
7796       # If it succeeded, then it was overridden by the user. We will use it
7797       # for the tool.
7798 
7799       # First remove it from the list of overridden variables, so we can test
7800       # for unknown variables in the end.
7801       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7802 
7803       # Check if the provided tool contains a complete path.
7804       tool_specified="$LS"
7805       tool_basename="${tool_specified##*/}"
7806       if test "x$tool_basename" = "x$tool_specified"; then
7807         # A command without a complete path is provided, search $PATH.
7808         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
7809 $as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
7810         # Extract the first word of "$tool_basename", so it can be a program name with args.
7811 set dummy $tool_basename; ac_word=$2
7812 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7813 $as_echo_n "checking for $ac_word... " >&6; }
7814 if ${ac_cv_path_LS+:} false; then :
7815   $as_echo_n "(cached) " >&6
7816 else
7817   case $LS in
7818   [\\/]* | ?:[\\/]*)
7819   ac_cv_path_LS="$LS" # Let the user override the test with a path.
7820   ;;
7821   *)
7822   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7823 for as_dir in $PATH
7824 do
7825   IFS=$as_save_IFS
7826   test -z "$as_dir" && as_dir=.
7827     for ac_exec_ext in '' $ac_executable_extensions; do
7828   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7829     ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
7830     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7831     break 2
7832   fi
7833 done
7834   done
7835 IFS=$as_save_IFS
7836 
7837   ;;
7838 esac
7839 fi
7840 LS=$ac_cv_path_LS
7841 if test -n "$LS"; then
7842   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
7843 $as_echo "$LS" >&6; }
7844 else
7845   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7846 $as_echo "no" >&6; }
7847 fi
7848 
7849 
7850         if test "x$LS" = x; then
7851           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
7852         fi
7853       else
7854         # Otherwise we believe it is a complete path. Use it as it is.
7855         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
7856 $as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
7857         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
7858 $as_echo_n "checking for LS... " >&6; }
7859         if test ! -x "$tool_specified"; then
7860           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
7861 $as_echo "not found" >&6; }
7862           as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
7863         fi
7864         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
7865 $as_echo "$tool_specified" >&6; }
7866       fi
7867     fi
7868   fi
7869 
7870 
7871 
7872   if test "x$LS" = x; then
7873     as_fn_error $? "Could not find required tool for LS" "$LINENO" 5
7874   fi
7875 
7876 
7877 
7878 
7879 
7880   # Publish this variable in the help.
7881 
7882 
7883   if test "x$MKDIR" = x; then
7884     # The variable is not set by user, try to locate tool using the code snippet
7885     for ac_prog in mkdir
7886 do
7887   # Extract the first word of "$ac_prog", so it can be a program name with args.
7888 set dummy $ac_prog; ac_word=$2
7889 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7890 $as_echo_n "checking for $ac_word... " >&6; }
7891 if ${ac_cv_path_MKDIR+:} false; then :
7892   $as_echo_n "(cached) " >&6
7893 else
7894   case $MKDIR in
7895   [\\/]* | ?:[\\/]*)
7896   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7897   ;;
7898   *)
7899   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7900 for as_dir in $PATH
7901 do
7902   IFS=$as_save_IFS
7903   test -z "$as_dir" && as_dir=.
7904     for ac_exec_ext in '' $ac_executable_extensions; do
7905   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7906     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7907     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7908     break 2
7909   fi
7910 done
7911   done
7912 IFS=$as_save_IFS
7913 
7914   ;;
7915 esac
7916 fi
7917 MKDIR=$ac_cv_path_MKDIR
7918 if test -n "$MKDIR"; then
7919   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
7920 $as_echo "$MKDIR" >&6; }
7921 else
7922   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7923 $as_echo "no" >&6; }
7924 fi
7925 
7926 
7927   test -n "$MKDIR" && break
7928 done
7929 
7930   else
7931     # The variable is set, but is it from the command line or the environment?
7932 
7933     # Try to remove the string !MKDIR! from our list.
7934     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKDIR!/}
7935     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
7936       # If it failed, the variable was not from the command line. Ignore it,
7937       # but warn the user (except for BASH, which is always set by the calling BASH).
7938       if test "xMKDIR" != xBASH; then
7939         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
7940 $as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
7941       fi
7942       # Try to locate tool using the code snippet
7943       for ac_prog in mkdir
7944 do
7945   # Extract the first word of "$ac_prog", so it can be a program name with args.
7946 set dummy $ac_prog; ac_word=$2
7947 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7948 $as_echo_n "checking for $ac_word... " >&6; }
7949 if ${ac_cv_path_MKDIR+:} false; then :
7950   $as_echo_n "(cached) " >&6
7951 else
7952   case $MKDIR in
7953   [\\/]* | ?:[\\/]*)
7954   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
7955   ;;
7956   *)
7957   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7958 for as_dir in $PATH
7959 do
7960   IFS=$as_save_IFS
7961   test -z "$as_dir" && as_dir=.
7962     for ac_exec_ext in '' $ac_executable_extensions; do
7963   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7964     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
7965     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7966     break 2
7967   fi
7968 done
7969   done
7970 IFS=$as_save_IFS
7971 
7972   ;;
7973 esac
7974 fi
7975 MKDIR=$ac_cv_path_MKDIR
7976 if test -n "$MKDIR"; then
7977   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
7978 $as_echo "$MKDIR" >&6; }
7979 else
7980   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7981 $as_echo "no" >&6; }
7982 fi
7983 
7984 
7985   test -n "$MKDIR" && break
7986 done
7987 
7988     else
7989       # If it succeeded, then it was overridden by the user. We will use it
7990       # for the tool.
7991 
7992       # First remove it from the list of overridden variables, so we can test
7993       # for unknown variables in the end.
7994       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
7995 
7996       # Check if the provided tool contains a complete path.
7997       tool_specified="$MKDIR"
7998       tool_basename="${tool_specified##*/}"
7999       if test "x$tool_basename" = "x$tool_specified"; then
8000         # A command without a complete path is provided, search $PATH.
8001         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
8002 $as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
8003         # Extract the first word of "$tool_basename", so it can be a program name with args.
8004 set dummy $tool_basename; ac_word=$2
8005 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8006 $as_echo_n "checking for $ac_word... " >&6; }
8007 if ${ac_cv_path_MKDIR+:} false; then :
8008   $as_echo_n "(cached) " >&6
8009 else
8010   case $MKDIR in
8011   [\\/]* | ?:[\\/]*)
8012   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
8013   ;;
8014   *)
8015   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8016 for as_dir in $PATH
8017 do
8018   IFS=$as_save_IFS
8019   test -z "$as_dir" && as_dir=.
8020     for ac_exec_ext in '' $ac_executable_extensions; do
8021   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8022     ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
8023     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8024     break 2
8025   fi
8026 done
8027   done
8028 IFS=$as_save_IFS
8029 
8030   ;;
8031 esac
8032 fi
8033 MKDIR=$ac_cv_path_MKDIR
8034 if test -n "$MKDIR"; then
8035   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
8036 $as_echo "$MKDIR" >&6; }
8037 else
8038   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8039 $as_echo "no" >&6; }
8040 fi
8041 
8042 
8043         if test "x$MKDIR" = x; then
8044           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8045         fi
8046       else
8047         # Otherwise we believe it is a complete path. Use it as it is.
8048         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
8049 $as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
8050         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
8051 $as_echo_n "checking for MKDIR... " >&6; }
8052         if test ! -x "$tool_specified"; then
8053           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8054 $as_echo "not found" >&6; }
8055           as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
8056         fi
8057         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8058 $as_echo "$tool_specified" >&6; }
8059       fi
8060     fi
8061   fi
8062 
8063 
8064 
8065   if test "x$MKDIR" = x; then
8066     as_fn_error $? "Could not find required tool for MKDIR" "$LINENO" 5
8067   fi
8068 
8069 
8070 
8071 
8072 
8073   # Publish this variable in the help.
8074 
8075 
8076   if test "x$MKTEMP" = x; then
8077     # The variable is not set by user, try to locate tool using the code snippet
8078     for ac_prog in mktemp
8079 do
8080   # Extract the first word of "$ac_prog", so it can be a program name with args.
8081 set dummy $ac_prog; ac_word=$2
8082 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8083 $as_echo_n "checking for $ac_word... " >&6; }
8084 if ${ac_cv_path_MKTEMP+:} false; then :
8085   $as_echo_n "(cached) " >&6
8086 else
8087   case $MKTEMP in
8088   [\\/]* | ?:[\\/]*)
8089   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8090   ;;
8091   *)
8092   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8093 for as_dir in $PATH
8094 do
8095   IFS=$as_save_IFS
8096   test -z "$as_dir" && as_dir=.
8097     for ac_exec_ext in '' $ac_executable_extensions; do
8098   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8099     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8100     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8101     break 2
8102   fi
8103 done
8104   done
8105 IFS=$as_save_IFS
8106 
8107   ;;
8108 esac
8109 fi
8110 MKTEMP=$ac_cv_path_MKTEMP
8111 if test -n "$MKTEMP"; then
8112   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8113 $as_echo "$MKTEMP" >&6; }
8114 else
8115   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8116 $as_echo "no" >&6; }
8117 fi
8118 
8119 
8120   test -n "$MKTEMP" && break
8121 done
8122 
8123   else
8124     # The variable is set, but is it from the command line or the environment?
8125 
8126     # Try to remove the string !MKTEMP! from our list.
8127     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MKTEMP!/}
8128     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8129       # If it failed, the variable was not from the command line. Ignore it,
8130       # but warn the user (except for BASH, which is always set by the calling BASH).
8131       if test "xMKTEMP" != xBASH; then
8132         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
8133 $as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
8134       fi
8135       # Try to locate tool using the code snippet
8136       for ac_prog in mktemp
8137 do
8138   # Extract the first word of "$ac_prog", so it can be a program name with args.
8139 set dummy $ac_prog; ac_word=$2
8140 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8141 $as_echo_n "checking for $ac_word... " >&6; }
8142 if ${ac_cv_path_MKTEMP+:} false; then :
8143   $as_echo_n "(cached) " >&6
8144 else
8145   case $MKTEMP in
8146   [\\/]* | ?:[\\/]*)
8147   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8148   ;;
8149   *)
8150   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8151 for as_dir in $PATH
8152 do
8153   IFS=$as_save_IFS
8154   test -z "$as_dir" && as_dir=.
8155     for ac_exec_ext in '' $ac_executable_extensions; do
8156   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8157     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8158     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8159     break 2
8160   fi
8161 done
8162   done
8163 IFS=$as_save_IFS
8164 
8165   ;;
8166 esac
8167 fi
8168 MKTEMP=$ac_cv_path_MKTEMP
8169 if test -n "$MKTEMP"; then
8170   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8171 $as_echo "$MKTEMP" >&6; }
8172 else
8173   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8174 $as_echo "no" >&6; }
8175 fi
8176 
8177 
8178   test -n "$MKTEMP" && break
8179 done
8180 
8181     else
8182       # If it succeeded, then it was overridden by the user. We will use it
8183       # for the tool.
8184 
8185       # First remove it from the list of overridden variables, so we can test
8186       # for unknown variables in the end.
8187       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8188 
8189       # Check if the provided tool contains a complete path.
8190       tool_specified="$MKTEMP"
8191       tool_basename="${tool_specified##*/}"
8192       if test "x$tool_basename" = "x$tool_specified"; then
8193         # A command without a complete path is provided, search $PATH.
8194         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
8195 $as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
8196         # Extract the first word of "$tool_basename", so it can be a program name with args.
8197 set dummy $tool_basename; ac_word=$2
8198 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8199 $as_echo_n "checking for $ac_word... " >&6; }
8200 if ${ac_cv_path_MKTEMP+:} false; then :
8201   $as_echo_n "(cached) " >&6
8202 else
8203   case $MKTEMP in
8204   [\\/]* | ?:[\\/]*)
8205   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
8206   ;;
8207   *)
8208   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8209 for as_dir in $PATH
8210 do
8211   IFS=$as_save_IFS
8212   test -z "$as_dir" && as_dir=.
8213     for ac_exec_ext in '' $ac_executable_extensions; do
8214   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8215     ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
8216     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8217     break 2
8218   fi
8219 done
8220   done
8221 IFS=$as_save_IFS
8222 
8223   ;;
8224 esac
8225 fi
8226 MKTEMP=$ac_cv_path_MKTEMP
8227 if test -n "$MKTEMP"; then
8228   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
8229 $as_echo "$MKTEMP" >&6; }
8230 else
8231   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8232 $as_echo "no" >&6; }
8233 fi
8234 
8235 
8236         if test "x$MKTEMP" = x; then
8237           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8238         fi
8239       else
8240         # Otherwise we believe it is a complete path. Use it as it is.
8241         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
8242 $as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
8243         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
8244 $as_echo_n "checking for MKTEMP... " >&6; }
8245         if test ! -x "$tool_specified"; then
8246           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8247 $as_echo "not found" >&6; }
8248           as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
8249         fi
8250         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8251 $as_echo "$tool_specified" >&6; }
8252       fi
8253     fi
8254   fi
8255 
8256 
8257 
8258   if test "x$MKTEMP" = x; then
8259     as_fn_error $? "Could not find required tool for MKTEMP" "$LINENO" 5
8260   fi
8261 
8262 
8263 
8264 
8265 
8266   # Publish this variable in the help.
8267 
8268 
8269   if test "x$MV" = x; then
8270     # The variable is not set by user, try to locate tool using the code snippet
8271     for ac_prog in mv
8272 do
8273   # Extract the first word of "$ac_prog", so it can be a program name with args.
8274 set dummy $ac_prog; ac_word=$2
8275 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8276 $as_echo_n "checking for $ac_word... " >&6; }
8277 if ${ac_cv_path_MV+:} false; then :
8278   $as_echo_n "(cached) " >&6
8279 else
8280   case $MV in
8281   [\\/]* | ?:[\\/]*)
8282   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8283   ;;
8284   *)
8285   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8286 for as_dir in $PATH
8287 do
8288   IFS=$as_save_IFS
8289   test -z "$as_dir" && as_dir=.
8290     for ac_exec_ext in '' $ac_executable_extensions; do
8291   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8292     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8293     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8294     break 2
8295   fi
8296 done
8297   done
8298 IFS=$as_save_IFS
8299 
8300   ;;
8301 esac
8302 fi
8303 MV=$ac_cv_path_MV
8304 if test -n "$MV"; then
8305   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8306 $as_echo "$MV" >&6; }
8307 else
8308   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8309 $as_echo "no" >&6; }
8310 fi
8311 
8312 
8313   test -n "$MV" && break
8314 done
8315 
8316   else
8317     # The variable is set, but is it from the command line or the environment?
8318 
8319     # Try to remove the string !MV! from our list.
8320     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!MV!/}
8321     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8322       # If it failed, the variable was not from the command line. Ignore it,
8323       # but warn the user (except for BASH, which is always set by the calling BASH).
8324       if test "xMV" != xBASH; then
8325         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
8326 $as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
8327       fi
8328       # Try to locate tool using the code snippet
8329       for ac_prog in mv
8330 do
8331   # Extract the first word of "$ac_prog", so it can be a program name with args.
8332 set dummy $ac_prog; ac_word=$2
8333 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8334 $as_echo_n "checking for $ac_word... " >&6; }
8335 if ${ac_cv_path_MV+:} false; then :
8336   $as_echo_n "(cached) " >&6
8337 else
8338   case $MV in
8339   [\\/]* | ?:[\\/]*)
8340   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8341   ;;
8342   *)
8343   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8344 for as_dir in $PATH
8345 do
8346   IFS=$as_save_IFS
8347   test -z "$as_dir" && as_dir=.
8348     for ac_exec_ext in '' $ac_executable_extensions; do
8349   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8350     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8351     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8352     break 2
8353   fi
8354 done
8355   done
8356 IFS=$as_save_IFS
8357 
8358   ;;
8359 esac
8360 fi
8361 MV=$ac_cv_path_MV
8362 if test -n "$MV"; then
8363   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8364 $as_echo "$MV" >&6; }
8365 else
8366   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8367 $as_echo "no" >&6; }
8368 fi
8369 
8370 
8371   test -n "$MV" && break
8372 done
8373 
8374     else
8375       # If it succeeded, then it was overridden by the user. We will use it
8376       # for the tool.
8377 
8378       # First remove it from the list of overridden variables, so we can test
8379       # for unknown variables in the end.
8380       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8381 
8382       # Check if the provided tool contains a complete path.
8383       tool_specified="$MV"
8384       tool_basename="${tool_specified##*/}"
8385       if test "x$tool_basename" = "x$tool_specified"; then
8386         # A command without a complete path is provided, search $PATH.
8387         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
8388 $as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
8389         # Extract the first word of "$tool_basename", so it can be a program name with args.
8390 set dummy $tool_basename; ac_word=$2
8391 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8392 $as_echo_n "checking for $ac_word... " >&6; }
8393 if ${ac_cv_path_MV+:} false; then :
8394   $as_echo_n "(cached) " >&6
8395 else
8396   case $MV in
8397   [\\/]* | ?:[\\/]*)
8398   ac_cv_path_MV="$MV" # Let the user override the test with a path.
8399   ;;
8400   *)
8401   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8402 for as_dir in $PATH
8403 do
8404   IFS=$as_save_IFS
8405   test -z "$as_dir" && as_dir=.
8406     for ac_exec_ext in '' $ac_executable_extensions; do
8407   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8408     ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
8409     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8410     break 2
8411   fi
8412 done
8413   done
8414 IFS=$as_save_IFS
8415 
8416   ;;
8417 esac
8418 fi
8419 MV=$ac_cv_path_MV
8420 if test -n "$MV"; then
8421   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
8422 $as_echo "$MV" >&6; }
8423 else
8424   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8425 $as_echo "no" >&6; }
8426 fi
8427 
8428 
8429         if test "x$MV" = x; then
8430           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8431         fi
8432       else
8433         # Otherwise we believe it is a complete path. Use it as it is.
8434         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
8435 $as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
8436         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
8437 $as_echo_n "checking for MV... " >&6; }
8438         if test ! -x "$tool_specified"; then
8439           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8440 $as_echo "not found" >&6; }
8441           as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
8442         fi
8443         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8444 $as_echo "$tool_specified" >&6; }
8445       fi
8446     fi
8447   fi
8448 
8449 
8450 
8451   if test "x$MV" = x; then
8452     as_fn_error $? "Could not find required tool for MV" "$LINENO" 5
8453   fi
8454 
8455 
8456 
8457 
8458 
8459   # Publish this variable in the help.
8460 
8461 
8462   if test "x$NAWK" = x; then
8463     # The variable is not set by user, try to locate tool using the code snippet
8464     for ac_prog in nawk gawk awk
8465 do
8466   # Extract the first word of "$ac_prog", so it can be a program name with args.
8467 set dummy $ac_prog; ac_word=$2
8468 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8469 $as_echo_n "checking for $ac_word... " >&6; }
8470 if ${ac_cv_path_NAWK+:} false; then :
8471   $as_echo_n "(cached) " >&6
8472 else
8473   case $NAWK in
8474   [\\/]* | ?:[\\/]*)
8475   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8476   ;;
8477   *)
8478   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8479 for as_dir in $PATH
8480 do
8481   IFS=$as_save_IFS
8482   test -z "$as_dir" && as_dir=.
8483     for ac_exec_ext in '' $ac_executable_extensions; do
8484   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8485     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8486     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8487     break 2
8488   fi
8489 done
8490   done
8491 IFS=$as_save_IFS
8492 
8493   ;;
8494 esac
8495 fi
8496 NAWK=$ac_cv_path_NAWK
8497 if test -n "$NAWK"; then
8498   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8499 $as_echo "$NAWK" >&6; }
8500 else
8501   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8502 $as_echo "no" >&6; }
8503 fi
8504 
8505 
8506   test -n "$NAWK" && break
8507 done
8508 
8509   else
8510     # The variable is set, but is it from the command line or the environment?
8511 
8512     # Try to remove the string !NAWK! from our list.
8513     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!NAWK!/}
8514     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8515       # If it failed, the variable was not from the command line. Ignore it,
8516       # but warn the user (except for BASH, which is always set by the calling BASH).
8517       if test "xNAWK" != xBASH; then
8518         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
8519 $as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
8520       fi
8521       # Try to locate tool using the code snippet
8522       for ac_prog in nawk gawk awk
8523 do
8524   # Extract the first word of "$ac_prog", so it can be a program name with args.
8525 set dummy $ac_prog; ac_word=$2
8526 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8527 $as_echo_n "checking for $ac_word... " >&6; }
8528 if ${ac_cv_path_NAWK+:} false; then :
8529   $as_echo_n "(cached) " >&6
8530 else
8531   case $NAWK in
8532   [\\/]* | ?:[\\/]*)
8533   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8534   ;;
8535   *)
8536   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8537 for as_dir in $PATH
8538 do
8539   IFS=$as_save_IFS
8540   test -z "$as_dir" && as_dir=.
8541     for ac_exec_ext in '' $ac_executable_extensions; do
8542   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8543     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8544     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8545     break 2
8546   fi
8547 done
8548   done
8549 IFS=$as_save_IFS
8550 
8551   ;;
8552 esac
8553 fi
8554 NAWK=$ac_cv_path_NAWK
8555 if test -n "$NAWK"; then
8556   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8557 $as_echo "$NAWK" >&6; }
8558 else
8559   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8560 $as_echo "no" >&6; }
8561 fi
8562 
8563 
8564   test -n "$NAWK" && break
8565 done
8566 
8567     else
8568       # If it succeeded, then it was overridden by the user. We will use it
8569       # for the tool.
8570 
8571       # First remove it from the list of overridden variables, so we can test
8572       # for unknown variables in the end.
8573       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8574 
8575       # Check if the provided tool contains a complete path.
8576       tool_specified="$NAWK"
8577       tool_basename="${tool_specified##*/}"
8578       if test "x$tool_basename" = "x$tool_specified"; then
8579         # A command without a complete path is provided, search $PATH.
8580         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
8581 $as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
8582         # Extract the first word of "$tool_basename", so it can be a program name with args.
8583 set dummy $tool_basename; ac_word=$2
8584 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8585 $as_echo_n "checking for $ac_word... " >&6; }
8586 if ${ac_cv_path_NAWK+:} false; then :
8587   $as_echo_n "(cached) " >&6
8588 else
8589   case $NAWK in
8590   [\\/]* | ?:[\\/]*)
8591   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
8592   ;;
8593   *)
8594   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8595 for as_dir in $PATH
8596 do
8597   IFS=$as_save_IFS
8598   test -z "$as_dir" && as_dir=.
8599     for ac_exec_ext in '' $ac_executable_extensions; do
8600   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8601     ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
8602     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8603     break 2
8604   fi
8605 done
8606   done
8607 IFS=$as_save_IFS
8608 
8609   ;;
8610 esac
8611 fi
8612 NAWK=$ac_cv_path_NAWK
8613 if test -n "$NAWK"; then
8614   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
8615 $as_echo "$NAWK" >&6; }
8616 else
8617   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8618 $as_echo "no" >&6; }
8619 fi
8620 
8621 
8622         if test "x$NAWK" = x; then
8623           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8624         fi
8625       else
8626         # Otherwise we believe it is a complete path. Use it as it is.
8627         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
8628 $as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
8629         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
8630 $as_echo_n "checking for NAWK... " >&6; }
8631         if test ! -x "$tool_specified"; then
8632           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8633 $as_echo "not found" >&6; }
8634           as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
8635         fi
8636         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8637 $as_echo "$tool_specified" >&6; }
8638       fi
8639     fi
8640   fi
8641 
8642 
8643 
8644   if test "x$NAWK" = x; then
8645     as_fn_error $? "Could not find required tool for NAWK" "$LINENO" 5
8646   fi
8647 
8648 
8649 
8650 
8651 
8652   # Publish this variable in the help.
8653 
8654 
8655   if test "x$PRINTF" = x; then
8656     # The variable is not set by user, try to locate tool using the code snippet
8657     for ac_prog in printf
8658 do
8659   # Extract the first word of "$ac_prog", so it can be a program name with args.
8660 set dummy $ac_prog; ac_word=$2
8661 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8662 $as_echo_n "checking for $ac_word... " >&6; }
8663 if ${ac_cv_path_PRINTF+:} false; then :
8664   $as_echo_n "(cached) " >&6
8665 else
8666   case $PRINTF in
8667   [\\/]* | ?:[\\/]*)
8668   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8669   ;;
8670   *)
8671   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8672 for as_dir in $PATH
8673 do
8674   IFS=$as_save_IFS
8675   test -z "$as_dir" && as_dir=.
8676     for ac_exec_ext in '' $ac_executable_extensions; do
8677   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8678     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8679     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8680     break 2
8681   fi
8682 done
8683   done
8684 IFS=$as_save_IFS
8685 
8686   ;;
8687 esac
8688 fi
8689 PRINTF=$ac_cv_path_PRINTF
8690 if test -n "$PRINTF"; then
8691   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8692 $as_echo "$PRINTF" >&6; }
8693 else
8694   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8695 $as_echo "no" >&6; }
8696 fi
8697 
8698 
8699   test -n "$PRINTF" && break
8700 done
8701 
8702   else
8703     # The variable is set, but is it from the command line or the environment?
8704 
8705     # Try to remove the string !PRINTF! from our list.
8706     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!PRINTF!/}
8707     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8708       # If it failed, the variable was not from the command line. Ignore it,
8709       # but warn the user (except for BASH, which is always set by the calling BASH).
8710       if test "xPRINTF" != xBASH; then
8711         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
8712 $as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
8713       fi
8714       # Try to locate tool using the code snippet
8715       for ac_prog in printf
8716 do
8717   # Extract the first word of "$ac_prog", so it can be a program name with args.
8718 set dummy $ac_prog; ac_word=$2
8719 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8720 $as_echo_n "checking for $ac_word... " >&6; }
8721 if ${ac_cv_path_PRINTF+:} false; then :
8722   $as_echo_n "(cached) " >&6
8723 else
8724   case $PRINTF in
8725   [\\/]* | ?:[\\/]*)
8726   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8727   ;;
8728   *)
8729   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8730 for as_dir in $PATH
8731 do
8732   IFS=$as_save_IFS
8733   test -z "$as_dir" && as_dir=.
8734     for ac_exec_ext in '' $ac_executable_extensions; do
8735   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8736     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8737     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8738     break 2
8739   fi
8740 done
8741   done
8742 IFS=$as_save_IFS
8743 
8744   ;;
8745 esac
8746 fi
8747 PRINTF=$ac_cv_path_PRINTF
8748 if test -n "$PRINTF"; then
8749   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8750 $as_echo "$PRINTF" >&6; }
8751 else
8752   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8753 $as_echo "no" >&6; }
8754 fi
8755 
8756 
8757   test -n "$PRINTF" && break
8758 done
8759 
8760     else
8761       # If it succeeded, then it was overridden by the user. We will use it
8762       # for the tool.
8763 
8764       # First remove it from the list of overridden variables, so we can test
8765       # for unknown variables in the end.
8766       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8767 
8768       # Check if the provided tool contains a complete path.
8769       tool_specified="$PRINTF"
8770       tool_basename="${tool_specified##*/}"
8771       if test "x$tool_basename" = "x$tool_specified"; then
8772         # A command without a complete path is provided, search $PATH.
8773         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
8774 $as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
8775         # Extract the first word of "$tool_basename", so it can be a program name with args.
8776 set dummy $tool_basename; ac_word=$2
8777 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8778 $as_echo_n "checking for $ac_word... " >&6; }
8779 if ${ac_cv_path_PRINTF+:} false; then :
8780   $as_echo_n "(cached) " >&6
8781 else
8782   case $PRINTF in
8783   [\\/]* | ?:[\\/]*)
8784   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
8785   ;;
8786   *)
8787   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8788 for as_dir in $PATH
8789 do
8790   IFS=$as_save_IFS
8791   test -z "$as_dir" && as_dir=.
8792     for ac_exec_ext in '' $ac_executable_extensions; do
8793   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8794     ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
8795     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8796     break 2
8797   fi
8798 done
8799   done
8800 IFS=$as_save_IFS
8801 
8802   ;;
8803 esac
8804 fi
8805 PRINTF=$ac_cv_path_PRINTF
8806 if test -n "$PRINTF"; then
8807   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
8808 $as_echo "$PRINTF" >&6; }
8809 else
8810   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8811 $as_echo "no" >&6; }
8812 fi
8813 
8814 
8815         if test "x$PRINTF" = x; then
8816           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
8817         fi
8818       else
8819         # Otherwise we believe it is a complete path. Use it as it is.
8820         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
8821 $as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
8822         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
8823 $as_echo_n "checking for PRINTF... " >&6; }
8824         if test ! -x "$tool_specified"; then
8825           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
8826 $as_echo "not found" >&6; }
8827           as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
8828         fi
8829         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
8830 $as_echo "$tool_specified" >&6; }
8831       fi
8832     fi
8833   fi
8834 
8835 
8836 
8837   if test "x$PRINTF" = x; then
8838     as_fn_error $? "Could not find required tool for PRINTF" "$LINENO" 5
8839   fi
8840 
8841 
8842 
8843 
8844 
8845   # Publish this variable in the help.
8846 
8847 
8848   if test "x$RM" = x; then
8849     # The variable is not set by user, try to locate tool using the code snippet
8850     for ac_prog in rm
8851 do
8852   # Extract the first word of "$ac_prog", so it can be a program name with args.
8853 set dummy $ac_prog; ac_word=$2
8854 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8855 $as_echo_n "checking for $ac_word... " >&6; }
8856 if ${ac_cv_path_RM+:} false; then :
8857   $as_echo_n "(cached) " >&6
8858 else
8859   case $RM in
8860   [\\/]* | ?:[\\/]*)
8861   ac_cv_path_RM="$RM" # Let the user override the test with a path.
8862   ;;
8863   *)
8864   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8865 for as_dir in $PATH
8866 do
8867   IFS=$as_save_IFS
8868   test -z "$as_dir" && as_dir=.
8869     for ac_exec_ext in '' $ac_executable_extensions; do
8870   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8871     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8872     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8873     break 2
8874   fi
8875 done
8876   done
8877 IFS=$as_save_IFS
8878 
8879   ;;
8880 esac
8881 fi
8882 RM=$ac_cv_path_RM
8883 if test -n "$RM"; then
8884   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8885 $as_echo "$RM" >&6; }
8886 else
8887   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8888 $as_echo "no" >&6; }
8889 fi
8890 
8891 
8892   test -n "$RM" && break
8893 done
8894 
8895   else
8896     # The variable is set, but is it from the command line or the environment?
8897 
8898     # Try to remove the string !RM! from our list.
8899     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!RM!/}
8900     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
8901       # If it failed, the variable was not from the command line. Ignore it,
8902       # but warn the user (except for BASH, which is always set by the calling BASH).
8903       if test "xRM" != xBASH; then
8904         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
8905 $as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
8906       fi
8907       # Try to locate tool using the code snippet
8908       for ac_prog in rm
8909 do
8910   # Extract the first word of "$ac_prog", so it can be a program name with args.
8911 set dummy $ac_prog; ac_word=$2
8912 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8913 $as_echo_n "checking for $ac_word... " >&6; }
8914 if ${ac_cv_path_RM+:} false; then :
8915   $as_echo_n "(cached) " >&6
8916 else
8917   case $RM in
8918   [\\/]* | ?:[\\/]*)
8919   ac_cv_path_RM="$RM" # Let the user override the test with a path.
8920   ;;
8921   *)
8922   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8923 for as_dir in $PATH
8924 do
8925   IFS=$as_save_IFS
8926   test -z "$as_dir" && as_dir=.
8927     for ac_exec_ext in '' $ac_executable_extensions; do
8928   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8929     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8930     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8931     break 2
8932   fi
8933 done
8934   done
8935 IFS=$as_save_IFS
8936 
8937   ;;
8938 esac
8939 fi
8940 RM=$ac_cv_path_RM
8941 if test -n "$RM"; then
8942   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
8943 $as_echo "$RM" >&6; }
8944 else
8945   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
8946 $as_echo "no" >&6; }
8947 fi
8948 
8949 
8950   test -n "$RM" && break
8951 done
8952 
8953     else
8954       # If it succeeded, then it was overridden by the user. We will use it
8955       # for the tool.
8956 
8957       # First remove it from the list of overridden variables, so we can test
8958       # for unknown variables in the end.
8959       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
8960 
8961       # Check if the provided tool contains a complete path.
8962       tool_specified="$RM"
8963       tool_basename="${tool_specified##*/}"
8964       if test "x$tool_basename" = "x$tool_specified"; then
8965         # A command without a complete path is provided, search $PATH.
8966         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
8967 $as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
8968         # Extract the first word of "$tool_basename", so it can be a program name with args.
8969 set dummy $tool_basename; ac_word=$2
8970 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
8971 $as_echo_n "checking for $ac_word... " >&6; }
8972 if ${ac_cv_path_RM+:} false; then :
8973   $as_echo_n "(cached) " >&6
8974 else
8975   case $RM in
8976   [\\/]* | ?:[\\/]*)
8977   ac_cv_path_RM="$RM" # Let the user override the test with a path.
8978   ;;
8979   *)
8980   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8981 for as_dir in $PATH
8982 do
8983   IFS=$as_save_IFS
8984   test -z "$as_dir" && as_dir=.
8985     for ac_exec_ext in '' $ac_executable_extensions; do
8986   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8987     ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
8988     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
8989     break 2
8990   fi
8991 done
8992   done
8993 IFS=$as_save_IFS
8994 
8995   ;;
8996 esac
8997 fi
8998 RM=$ac_cv_path_RM
8999 if test -n "$RM"; then
9000   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
9001 $as_echo "$RM" >&6; }
9002 else
9003   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9004 $as_echo "no" >&6; }
9005 fi
9006 
9007 
9008         if test "x$RM" = x; then
9009           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9010         fi
9011       else
9012         # Otherwise we believe it is a complete path. Use it as it is.
9013         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
9014 $as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
9015         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
9016 $as_echo_n "checking for RM... " >&6; }
9017         if test ! -x "$tool_specified"; then
9018           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9019 $as_echo "not found" >&6; }
9020           as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
9021         fi
9022         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9023 $as_echo "$tool_specified" >&6; }
9024       fi
9025     fi
9026   fi
9027 
9028 
9029 
9030   if test "x$RM" = x; then
9031     as_fn_error $? "Could not find required tool for RM" "$LINENO" 5
9032   fi
9033 
9034 
9035 
9036 
9037 
9038   # Publish this variable in the help.
9039 
9040 
9041   if test "x$SH" = x; then
9042     # The variable is not set by user, try to locate tool using the code snippet
9043     for ac_prog in sh
9044 do
9045   # Extract the first word of "$ac_prog", so it can be a program name with args.
9046 set dummy $ac_prog; ac_word=$2
9047 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9048 $as_echo_n "checking for $ac_word... " >&6; }
9049 if ${ac_cv_path_SH+:} false; then :
9050   $as_echo_n "(cached) " >&6
9051 else
9052   case $SH in
9053   [\\/]* | ?:[\\/]*)
9054   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9055   ;;
9056   *)
9057   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9058 for as_dir in $PATH
9059 do
9060   IFS=$as_save_IFS
9061   test -z "$as_dir" && as_dir=.
9062     for ac_exec_ext in '' $ac_executable_extensions; do
9063   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9064     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9065     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9066     break 2
9067   fi
9068 done
9069   done
9070 IFS=$as_save_IFS
9071 
9072   ;;
9073 esac
9074 fi
9075 SH=$ac_cv_path_SH
9076 if test -n "$SH"; then
9077   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9078 $as_echo "$SH" >&6; }
9079 else
9080   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9081 $as_echo "no" >&6; }
9082 fi
9083 
9084 
9085   test -n "$SH" && break
9086 done
9087 
9088   else
9089     # The variable is set, but is it from the command line or the environment?
9090 
9091     # Try to remove the string !SH! from our list.
9092     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SH!/}
9093     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9094       # If it failed, the variable was not from the command line. Ignore it,
9095       # but warn the user (except for BASH, which is always set by the calling BASH).
9096       if test "xSH" != xBASH; then
9097         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
9098 $as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
9099       fi
9100       # Try to locate tool using the code snippet
9101       for ac_prog in sh
9102 do
9103   # Extract the first word of "$ac_prog", so it can be a program name with args.
9104 set dummy $ac_prog; ac_word=$2
9105 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9106 $as_echo_n "checking for $ac_word... " >&6; }
9107 if ${ac_cv_path_SH+:} false; then :
9108   $as_echo_n "(cached) " >&6
9109 else
9110   case $SH in
9111   [\\/]* | ?:[\\/]*)
9112   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9113   ;;
9114   *)
9115   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9116 for as_dir in $PATH
9117 do
9118   IFS=$as_save_IFS
9119   test -z "$as_dir" && as_dir=.
9120     for ac_exec_ext in '' $ac_executable_extensions; do
9121   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9122     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9123     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9124     break 2
9125   fi
9126 done
9127   done
9128 IFS=$as_save_IFS
9129 
9130   ;;
9131 esac
9132 fi
9133 SH=$ac_cv_path_SH
9134 if test -n "$SH"; then
9135   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9136 $as_echo "$SH" >&6; }
9137 else
9138   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9139 $as_echo "no" >&6; }
9140 fi
9141 
9142 
9143   test -n "$SH" && break
9144 done
9145 
9146     else
9147       # If it succeeded, then it was overridden by the user. We will use it
9148       # for the tool.
9149 
9150       # First remove it from the list of overridden variables, so we can test
9151       # for unknown variables in the end.
9152       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9153 
9154       # Check if the provided tool contains a complete path.
9155       tool_specified="$SH"
9156       tool_basename="${tool_specified##*/}"
9157       if test "x$tool_basename" = "x$tool_specified"; then
9158         # A command without a complete path is provided, search $PATH.
9159         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
9160 $as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
9161         # Extract the first word of "$tool_basename", so it can be a program name with args.
9162 set dummy $tool_basename; ac_word=$2
9163 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9164 $as_echo_n "checking for $ac_word... " >&6; }
9165 if ${ac_cv_path_SH+:} false; then :
9166   $as_echo_n "(cached) " >&6
9167 else
9168   case $SH in
9169   [\\/]* | ?:[\\/]*)
9170   ac_cv_path_SH="$SH" # Let the user override the test with a path.
9171   ;;
9172   *)
9173   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9174 for as_dir in $PATH
9175 do
9176   IFS=$as_save_IFS
9177   test -z "$as_dir" && as_dir=.
9178     for ac_exec_ext in '' $ac_executable_extensions; do
9179   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9180     ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
9181     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9182     break 2
9183   fi
9184 done
9185   done
9186 IFS=$as_save_IFS
9187 
9188   ;;
9189 esac
9190 fi
9191 SH=$ac_cv_path_SH
9192 if test -n "$SH"; then
9193   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
9194 $as_echo "$SH" >&6; }
9195 else
9196   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9197 $as_echo "no" >&6; }
9198 fi
9199 
9200 
9201         if test "x$SH" = x; then
9202           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9203         fi
9204       else
9205         # Otherwise we believe it is a complete path. Use it as it is.
9206         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
9207 $as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
9208         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
9209 $as_echo_n "checking for SH... " >&6; }
9210         if test ! -x "$tool_specified"; then
9211           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9212 $as_echo "not found" >&6; }
9213           as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
9214         fi
9215         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9216 $as_echo "$tool_specified" >&6; }
9217       fi
9218     fi
9219   fi
9220 
9221 
9222 
9223   if test "x$SH" = x; then
9224     as_fn_error $? "Could not find required tool for SH" "$LINENO" 5
9225   fi
9226 
9227 
9228 
9229 
9230 
9231   # Publish this variable in the help.
9232 
9233 
9234   if test "x$SORT" = x; then
9235     # The variable is not set by user, try to locate tool using the code snippet
9236     for ac_prog in sort
9237 do
9238   # Extract the first word of "$ac_prog", so it can be a program name with args.
9239 set dummy $ac_prog; ac_word=$2
9240 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9241 $as_echo_n "checking for $ac_word... " >&6; }
9242 if ${ac_cv_path_SORT+:} false; then :
9243   $as_echo_n "(cached) " >&6
9244 else
9245   case $SORT in
9246   [\\/]* | ?:[\\/]*)
9247   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9248   ;;
9249   *)
9250   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9251 for as_dir in $PATH
9252 do
9253   IFS=$as_save_IFS
9254   test -z "$as_dir" && as_dir=.
9255     for ac_exec_ext in '' $ac_executable_extensions; do
9256   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9257     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9258     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9259     break 2
9260   fi
9261 done
9262   done
9263 IFS=$as_save_IFS
9264 
9265   ;;
9266 esac
9267 fi
9268 SORT=$ac_cv_path_SORT
9269 if test -n "$SORT"; then
9270   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9271 $as_echo "$SORT" >&6; }
9272 else
9273   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9274 $as_echo "no" >&6; }
9275 fi
9276 
9277 
9278   test -n "$SORT" && break
9279 done
9280 
9281   else
9282     # The variable is set, but is it from the command line or the environment?
9283 
9284     # Try to remove the string !SORT! from our list.
9285     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SORT!/}
9286     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9287       # If it failed, the variable was not from the command line. Ignore it,
9288       # but warn the user (except for BASH, which is always set by the calling BASH).
9289       if test "xSORT" != xBASH; then
9290         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
9291 $as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
9292       fi
9293       # Try to locate tool using the code snippet
9294       for ac_prog in sort
9295 do
9296   # Extract the first word of "$ac_prog", so it can be a program name with args.
9297 set dummy $ac_prog; ac_word=$2
9298 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9299 $as_echo_n "checking for $ac_word... " >&6; }
9300 if ${ac_cv_path_SORT+:} false; then :
9301   $as_echo_n "(cached) " >&6
9302 else
9303   case $SORT in
9304   [\\/]* | ?:[\\/]*)
9305   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9306   ;;
9307   *)
9308   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9309 for as_dir in $PATH
9310 do
9311   IFS=$as_save_IFS
9312   test -z "$as_dir" && as_dir=.
9313     for ac_exec_ext in '' $ac_executable_extensions; do
9314   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9315     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9316     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9317     break 2
9318   fi
9319 done
9320   done
9321 IFS=$as_save_IFS
9322 
9323   ;;
9324 esac
9325 fi
9326 SORT=$ac_cv_path_SORT
9327 if test -n "$SORT"; then
9328   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9329 $as_echo "$SORT" >&6; }
9330 else
9331   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9332 $as_echo "no" >&6; }
9333 fi
9334 
9335 
9336   test -n "$SORT" && break
9337 done
9338 
9339     else
9340       # If it succeeded, then it was overridden by the user. We will use it
9341       # for the tool.
9342 
9343       # First remove it from the list of overridden variables, so we can test
9344       # for unknown variables in the end.
9345       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9346 
9347       # Check if the provided tool contains a complete path.
9348       tool_specified="$SORT"
9349       tool_basename="${tool_specified##*/}"
9350       if test "x$tool_basename" = "x$tool_specified"; then
9351         # A command without a complete path is provided, search $PATH.
9352         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
9353 $as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
9354         # Extract the first word of "$tool_basename", so it can be a program name with args.
9355 set dummy $tool_basename; ac_word=$2
9356 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9357 $as_echo_n "checking for $ac_word... " >&6; }
9358 if ${ac_cv_path_SORT+:} false; then :
9359   $as_echo_n "(cached) " >&6
9360 else
9361   case $SORT in
9362   [\\/]* | ?:[\\/]*)
9363   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
9364   ;;
9365   *)
9366   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9367 for as_dir in $PATH
9368 do
9369   IFS=$as_save_IFS
9370   test -z "$as_dir" && as_dir=.
9371     for ac_exec_ext in '' $ac_executable_extensions; do
9372   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9373     ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
9374     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9375     break 2
9376   fi
9377 done
9378   done
9379 IFS=$as_save_IFS
9380 
9381   ;;
9382 esac
9383 fi
9384 SORT=$ac_cv_path_SORT
9385 if test -n "$SORT"; then
9386   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
9387 $as_echo "$SORT" >&6; }
9388 else
9389   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9390 $as_echo "no" >&6; }
9391 fi
9392 
9393 
9394         if test "x$SORT" = x; then
9395           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9396         fi
9397       else
9398         # Otherwise we believe it is a complete path. Use it as it is.
9399         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
9400 $as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
9401         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
9402 $as_echo_n "checking for SORT... " >&6; }
9403         if test ! -x "$tool_specified"; then
9404           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9405 $as_echo "not found" >&6; }
9406           as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
9407         fi
9408         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9409 $as_echo "$tool_specified" >&6; }
9410       fi
9411     fi
9412   fi
9413 
9414 
9415 
9416   if test "x$SORT" = x; then
9417     as_fn_error $? "Could not find required tool for SORT" "$LINENO" 5
9418   fi
9419 
9420 
9421 
9422 
9423 
9424   # Publish this variable in the help.
9425 
9426 
9427   if test "x$TAIL" = x; then
9428     # The variable is not set by user, try to locate tool using the code snippet
9429     for ac_prog in tail
9430 do
9431   # Extract the first word of "$ac_prog", so it can be a program name with args.
9432 set dummy $ac_prog; ac_word=$2
9433 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9434 $as_echo_n "checking for $ac_word... " >&6; }
9435 if ${ac_cv_path_TAIL+:} false; then :
9436   $as_echo_n "(cached) " >&6
9437 else
9438   case $TAIL in
9439   [\\/]* | ?:[\\/]*)
9440   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9441   ;;
9442   *)
9443   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9444 for as_dir in $PATH
9445 do
9446   IFS=$as_save_IFS
9447   test -z "$as_dir" && as_dir=.
9448     for ac_exec_ext in '' $ac_executable_extensions; do
9449   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9450     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9451     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9452     break 2
9453   fi
9454 done
9455   done
9456 IFS=$as_save_IFS
9457 
9458   ;;
9459 esac
9460 fi
9461 TAIL=$ac_cv_path_TAIL
9462 if test -n "$TAIL"; then
9463   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9464 $as_echo "$TAIL" >&6; }
9465 else
9466   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9467 $as_echo "no" >&6; }
9468 fi
9469 
9470 
9471   test -n "$TAIL" && break
9472 done
9473 
9474   else
9475     # The variable is set, but is it from the command line or the environment?
9476 
9477     # Try to remove the string !TAIL! from our list.
9478     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAIL!/}
9479     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9480       # If it failed, the variable was not from the command line. Ignore it,
9481       # but warn the user (except for BASH, which is always set by the calling BASH).
9482       if test "xTAIL" != xBASH; then
9483         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
9484 $as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
9485       fi
9486       # Try to locate tool using the code snippet
9487       for ac_prog in tail
9488 do
9489   # Extract the first word of "$ac_prog", so it can be a program name with args.
9490 set dummy $ac_prog; ac_word=$2
9491 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9492 $as_echo_n "checking for $ac_word... " >&6; }
9493 if ${ac_cv_path_TAIL+:} false; then :
9494   $as_echo_n "(cached) " >&6
9495 else
9496   case $TAIL in
9497   [\\/]* | ?:[\\/]*)
9498   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9499   ;;
9500   *)
9501   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9502 for as_dir in $PATH
9503 do
9504   IFS=$as_save_IFS
9505   test -z "$as_dir" && as_dir=.
9506     for ac_exec_ext in '' $ac_executable_extensions; do
9507   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9508     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9509     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9510     break 2
9511   fi
9512 done
9513   done
9514 IFS=$as_save_IFS
9515 
9516   ;;
9517 esac
9518 fi
9519 TAIL=$ac_cv_path_TAIL
9520 if test -n "$TAIL"; then
9521   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9522 $as_echo "$TAIL" >&6; }
9523 else
9524   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9525 $as_echo "no" >&6; }
9526 fi
9527 
9528 
9529   test -n "$TAIL" && break
9530 done
9531 
9532     else
9533       # If it succeeded, then it was overridden by the user. We will use it
9534       # for the tool.
9535 
9536       # First remove it from the list of overridden variables, so we can test
9537       # for unknown variables in the end.
9538       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9539 
9540       # Check if the provided tool contains a complete path.
9541       tool_specified="$TAIL"
9542       tool_basename="${tool_specified##*/}"
9543       if test "x$tool_basename" = "x$tool_specified"; then
9544         # A command without a complete path is provided, search $PATH.
9545         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
9546 $as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
9547         # Extract the first word of "$tool_basename", so it can be a program name with args.
9548 set dummy $tool_basename; ac_word=$2
9549 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9550 $as_echo_n "checking for $ac_word... " >&6; }
9551 if ${ac_cv_path_TAIL+:} false; then :
9552   $as_echo_n "(cached) " >&6
9553 else
9554   case $TAIL in
9555   [\\/]* | ?:[\\/]*)
9556   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
9557   ;;
9558   *)
9559   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9560 for as_dir in $PATH
9561 do
9562   IFS=$as_save_IFS
9563   test -z "$as_dir" && as_dir=.
9564     for ac_exec_ext in '' $ac_executable_extensions; do
9565   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9566     ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
9567     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9568     break 2
9569   fi
9570 done
9571   done
9572 IFS=$as_save_IFS
9573 
9574   ;;
9575 esac
9576 fi
9577 TAIL=$ac_cv_path_TAIL
9578 if test -n "$TAIL"; then
9579   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
9580 $as_echo "$TAIL" >&6; }
9581 else
9582   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9583 $as_echo "no" >&6; }
9584 fi
9585 
9586 
9587         if test "x$TAIL" = x; then
9588           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9589         fi
9590       else
9591         # Otherwise we believe it is a complete path. Use it as it is.
9592         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
9593 $as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
9594         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
9595 $as_echo_n "checking for TAIL... " >&6; }
9596         if test ! -x "$tool_specified"; then
9597           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9598 $as_echo "not found" >&6; }
9599           as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
9600         fi
9601         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9602 $as_echo "$tool_specified" >&6; }
9603       fi
9604     fi
9605   fi
9606 
9607 
9608 
9609   if test "x$TAIL" = x; then
9610     as_fn_error $? "Could not find required tool for TAIL" "$LINENO" 5
9611   fi
9612 
9613 
9614 
9615 
9616 
9617   # Publish this variable in the help.
9618 
9619 
9620   if test "x$TAR" = x; then
9621     # The variable is not set by user, try to locate tool using the code snippet
9622     for ac_prog in tar
9623 do
9624   # Extract the first word of "$ac_prog", so it can be a program name with args.
9625 set dummy $ac_prog; ac_word=$2
9626 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9627 $as_echo_n "checking for $ac_word... " >&6; }
9628 if ${ac_cv_path_TAR+:} false; then :
9629   $as_echo_n "(cached) " >&6
9630 else
9631   case $TAR in
9632   [\\/]* | ?:[\\/]*)
9633   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9634   ;;
9635   *)
9636   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9637 for as_dir in $PATH
9638 do
9639   IFS=$as_save_IFS
9640   test -z "$as_dir" && as_dir=.
9641     for ac_exec_ext in '' $ac_executable_extensions; do
9642   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9643     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9644     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9645     break 2
9646   fi
9647 done
9648   done
9649 IFS=$as_save_IFS
9650 
9651   ;;
9652 esac
9653 fi
9654 TAR=$ac_cv_path_TAR
9655 if test -n "$TAR"; then
9656   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9657 $as_echo "$TAR" >&6; }
9658 else
9659   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9660 $as_echo "no" >&6; }
9661 fi
9662 
9663 
9664   test -n "$TAR" && break
9665 done
9666 
9667   else
9668     # The variable is set, but is it from the command line or the environment?
9669 
9670     # Try to remove the string !TAR! from our list.
9671     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TAR!/}
9672     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9673       # If it failed, the variable was not from the command line. Ignore it,
9674       # but warn the user (except for BASH, which is always set by the calling BASH).
9675       if test "xTAR" != xBASH; then
9676         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
9677 $as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
9678       fi
9679       # Try to locate tool using the code snippet
9680       for ac_prog in tar
9681 do
9682   # Extract the first word of "$ac_prog", so it can be a program name with args.
9683 set dummy $ac_prog; ac_word=$2
9684 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9685 $as_echo_n "checking for $ac_word... " >&6; }
9686 if ${ac_cv_path_TAR+:} false; then :
9687   $as_echo_n "(cached) " >&6
9688 else
9689   case $TAR in
9690   [\\/]* | ?:[\\/]*)
9691   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9692   ;;
9693   *)
9694   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9695 for as_dir in $PATH
9696 do
9697   IFS=$as_save_IFS
9698   test -z "$as_dir" && as_dir=.
9699     for ac_exec_ext in '' $ac_executable_extensions; do
9700   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9701     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9702     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9703     break 2
9704   fi
9705 done
9706   done
9707 IFS=$as_save_IFS
9708 
9709   ;;
9710 esac
9711 fi
9712 TAR=$ac_cv_path_TAR
9713 if test -n "$TAR"; then
9714   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9715 $as_echo "$TAR" >&6; }
9716 else
9717   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9718 $as_echo "no" >&6; }
9719 fi
9720 
9721 
9722   test -n "$TAR" && break
9723 done
9724 
9725     else
9726       # If it succeeded, then it was overridden by the user. We will use it
9727       # for the tool.
9728 
9729       # First remove it from the list of overridden variables, so we can test
9730       # for unknown variables in the end.
9731       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9732 
9733       # Check if the provided tool contains a complete path.
9734       tool_specified="$TAR"
9735       tool_basename="${tool_specified##*/}"
9736       if test "x$tool_basename" = "x$tool_specified"; then
9737         # A command without a complete path is provided, search $PATH.
9738         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
9739 $as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
9740         # Extract the first word of "$tool_basename", so it can be a program name with args.
9741 set dummy $tool_basename; ac_word=$2
9742 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9743 $as_echo_n "checking for $ac_word... " >&6; }
9744 if ${ac_cv_path_TAR+:} false; then :
9745   $as_echo_n "(cached) " >&6
9746 else
9747   case $TAR in
9748   [\\/]* | ?:[\\/]*)
9749   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
9750   ;;
9751   *)
9752   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9753 for as_dir in $PATH
9754 do
9755   IFS=$as_save_IFS
9756   test -z "$as_dir" && as_dir=.
9757     for ac_exec_ext in '' $ac_executable_extensions; do
9758   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9759     ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
9760     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9761     break 2
9762   fi
9763 done
9764   done
9765 IFS=$as_save_IFS
9766 
9767   ;;
9768 esac
9769 fi
9770 TAR=$ac_cv_path_TAR
9771 if test -n "$TAR"; then
9772   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
9773 $as_echo "$TAR" >&6; }
9774 else
9775   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9776 $as_echo "no" >&6; }
9777 fi
9778 
9779 
9780         if test "x$TAR" = x; then
9781           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9782         fi
9783       else
9784         # Otherwise we believe it is a complete path. Use it as it is.
9785         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
9786 $as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
9787         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
9788 $as_echo_n "checking for TAR... " >&6; }
9789         if test ! -x "$tool_specified"; then
9790           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9791 $as_echo "not found" >&6; }
9792           as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
9793         fi
9794         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9795 $as_echo "$tool_specified" >&6; }
9796       fi
9797     fi
9798   fi
9799 
9800 
9801 
9802   if test "x$TAR" = x; then
9803     as_fn_error $? "Could not find required tool for TAR" "$LINENO" 5
9804   fi
9805 
9806 
9807 
9808 
9809 
9810   # Publish this variable in the help.
9811 
9812 
9813   if test "x$TEE" = x; then
9814     # The variable is not set by user, try to locate tool using the code snippet
9815     for ac_prog in tee
9816 do
9817   # Extract the first word of "$ac_prog", so it can be a program name with args.
9818 set dummy $ac_prog; ac_word=$2
9819 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9820 $as_echo_n "checking for $ac_word... " >&6; }
9821 if ${ac_cv_path_TEE+:} false; then :
9822   $as_echo_n "(cached) " >&6
9823 else
9824   case $TEE in
9825   [\\/]* | ?:[\\/]*)
9826   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9827   ;;
9828   *)
9829   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9830 for as_dir in $PATH
9831 do
9832   IFS=$as_save_IFS
9833   test -z "$as_dir" && as_dir=.
9834     for ac_exec_ext in '' $ac_executable_extensions; do
9835   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9836     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9837     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9838     break 2
9839   fi
9840 done
9841   done
9842 IFS=$as_save_IFS
9843 
9844   ;;
9845 esac
9846 fi
9847 TEE=$ac_cv_path_TEE
9848 if test -n "$TEE"; then
9849   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9850 $as_echo "$TEE" >&6; }
9851 else
9852   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9853 $as_echo "no" >&6; }
9854 fi
9855 
9856 
9857   test -n "$TEE" && break
9858 done
9859 
9860   else
9861     # The variable is set, but is it from the command line or the environment?
9862 
9863     # Try to remove the string !TEE! from our list.
9864     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TEE!/}
9865     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
9866       # If it failed, the variable was not from the command line. Ignore it,
9867       # but warn the user (except for BASH, which is always set by the calling BASH).
9868       if test "xTEE" != xBASH; then
9869         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
9870 $as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
9871       fi
9872       # Try to locate tool using the code snippet
9873       for ac_prog in tee
9874 do
9875   # Extract the first word of "$ac_prog", so it can be a program name with args.
9876 set dummy $ac_prog; ac_word=$2
9877 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9878 $as_echo_n "checking for $ac_word... " >&6; }
9879 if ${ac_cv_path_TEE+:} false; then :
9880   $as_echo_n "(cached) " >&6
9881 else
9882   case $TEE in
9883   [\\/]* | ?:[\\/]*)
9884   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9885   ;;
9886   *)
9887   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9888 for as_dir in $PATH
9889 do
9890   IFS=$as_save_IFS
9891   test -z "$as_dir" && as_dir=.
9892     for ac_exec_ext in '' $ac_executable_extensions; do
9893   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9894     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9895     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9896     break 2
9897   fi
9898 done
9899   done
9900 IFS=$as_save_IFS
9901 
9902   ;;
9903 esac
9904 fi
9905 TEE=$ac_cv_path_TEE
9906 if test -n "$TEE"; then
9907   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9908 $as_echo "$TEE" >&6; }
9909 else
9910   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9911 $as_echo "no" >&6; }
9912 fi
9913 
9914 
9915   test -n "$TEE" && break
9916 done
9917 
9918     else
9919       # If it succeeded, then it was overridden by the user. We will use it
9920       # for the tool.
9921 
9922       # First remove it from the list of overridden variables, so we can test
9923       # for unknown variables in the end.
9924       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
9925 
9926       # Check if the provided tool contains a complete path.
9927       tool_specified="$TEE"
9928       tool_basename="${tool_specified##*/}"
9929       if test "x$tool_basename" = "x$tool_specified"; then
9930         # A command without a complete path is provided, search $PATH.
9931         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
9932 $as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
9933         # Extract the first word of "$tool_basename", so it can be a program name with args.
9934 set dummy $tool_basename; ac_word=$2
9935 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
9936 $as_echo_n "checking for $ac_word... " >&6; }
9937 if ${ac_cv_path_TEE+:} false; then :
9938   $as_echo_n "(cached) " >&6
9939 else
9940   case $TEE in
9941   [\\/]* | ?:[\\/]*)
9942   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
9943   ;;
9944   *)
9945   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9946 for as_dir in $PATH
9947 do
9948   IFS=$as_save_IFS
9949   test -z "$as_dir" && as_dir=.
9950     for ac_exec_ext in '' $ac_executable_extensions; do
9951   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9952     ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
9953     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
9954     break 2
9955   fi
9956 done
9957   done
9958 IFS=$as_save_IFS
9959 
9960   ;;
9961 esac
9962 fi
9963 TEE=$ac_cv_path_TEE
9964 if test -n "$TEE"; then
9965   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
9966 $as_echo "$TEE" >&6; }
9967 else
9968   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
9969 $as_echo "no" >&6; }
9970 fi
9971 
9972 
9973         if test "x$TEE" = x; then
9974           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
9975         fi
9976       else
9977         # Otherwise we believe it is a complete path. Use it as it is.
9978         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
9979 $as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
9980         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
9981 $as_echo_n "checking for TEE... " >&6; }
9982         if test ! -x "$tool_specified"; then
9983           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9984 $as_echo "not found" >&6; }
9985           as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
9986         fi
9987         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
9988 $as_echo "$tool_specified" >&6; }
9989       fi
9990     fi
9991   fi
9992 
9993 
9994 
9995   if test "x$TEE" = x; then
9996     as_fn_error $? "Could not find required tool for TEE" "$LINENO" 5
9997   fi
9998 
9999 
10000 
10001 
10002 
10003   # Publish this variable in the help.
10004 
10005 
10006   if test "x$TOUCH" = x; then
10007     # The variable is not set by user, try to locate tool using the code snippet
10008     for ac_prog in touch
10009 do
10010   # Extract the first word of "$ac_prog", so it can be a program name with args.
10011 set dummy $ac_prog; ac_word=$2
10012 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10013 $as_echo_n "checking for $ac_word... " >&6; }
10014 if ${ac_cv_path_TOUCH+:} false; then :
10015   $as_echo_n "(cached) " >&6
10016 else
10017   case $TOUCH in
10018   [\\/]* | ?:[\\/]*)
10019   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10020   ;;
10021   *)
10022   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10023 for as_dir in $PATH
10024 do
10025   IFS=$as_save_IFS
10026   test -z "$as_dir" && as_dir=.
10027     for ac_exec_ext in '' $ac_executable_extensions; do
10028   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10029     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10030     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10031     break 2
10032   fi
10033 done
10034   done
10035 IFS=$as_save_IFS
10036 
10037   ;;
10038 esac
10039 fi
10040 TOUCH=$ac_cv_path_TOUCH
10041 if test -n "$TOUCH"; then
10042   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10043 $as_echo "$TOUCH" >&6; }
10044 else
10045   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10046 $as_echo "no" >&6; }
10047 fi
10048 
10049 
10050   test -n "$TOUCH" && break
10051 done
10052 
10053   else
10054     # The variable is set, but is it from the command line or the environment?
10055 
10056     # Try to remove the string !TOUCH! from our list.
10057     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TOUCH!/}
10058     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10059       # If it failed, the variable was not from the command line. Ignore it,
10060       # but warn the user (except for BASH, which is always set by the calling BASH).
10061       if test "xTOUCH" != xBASH; then
10062         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
10063 $as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
10064       fi
10065       # Try to locate tool using the code snippet
10066       for ac_prog in touch
10067 do
10068   # Extract the first word of "$ac_prog", so it can be a program name with args.
10069 set dummy $ac_prog; ac_word=$2
10070 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10071 $as_echo_n "checking for $ac_word... " >&6; }
10072 if ${ac_cv_path_TOUCH+:} false; then :
10073   $as_echo_n "(cached) " >&6
10074 else
10075   case $TOUCH in
10076   [\\/]* | ?:[\\/]*)
10077   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10078   ;;
10079   *)
10080   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10081 for as_dir in $PATH
10082 do
10083   IFS=$as_save_IFS
10084   test -z "$as_dir" && as_dir=.
10085     for ac_exec_ext in '' $ac_executable_extensions; do
10086   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10087     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10088     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10089     break 2
10090   fi
10091 done
10092   done
10093 IFS=$as_save_IFS
10094 
10095   ;;
10096 esac
10097 fi
10098 TOUCH=$ac_cv_path_TOUCH
10099 if test -n "$TOUCH"; then
10100   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10101 $as_echo "$TOUCH" >&6; }
10102 else
10103   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10104 $as_echo "no" >&6; }
10105 fi
10106 
10107 
10108   test -n "$TOUCH" && break
10109 done
10110 
10111     else
10112       # If it succeeded, then it was overridden by the user. We will use it
10113       # for the tool.
10114 
10115       # First remove it from the list of overridden variables, so we can test
10116       # for unknown variables in the end.
10117       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10118 
10119       # Check if the provided tool contains a complete path.
10120       tool_specified="$TOUCH"
10121       tool_basename="${tool_specified##*/}"
10122       if test "x$tool_basename" = "x$tool_specified"; then
10123         # A command without a complete path is provided, search $PATH.
10124         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
10125 $as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
10126         # Extract the first word of "$tool_basename", so it can be a program name with args.
10127 set dummy $tool_basename; ac_word=$2
10128 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10129 $as_echo_n "checking for $ac_word... " >&6; }
10130 if ${ac_cv_path_TOUCH+:} false; then :
10131   $as_echo_n "(cached) " >&6
10132 else
10133   case $TOUCH in
10134   [\\/]* | ?:[\\/]*)
10135   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
10136   ;;
10137   *)
10138   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10139 for as_dir in $PATH
10140 do
10141   IFS=$as_save_IFS
10142   test -z "$as_dir" && as_dir=.
10143     for ac_exec_ext in '' $ac_executable_extensions; do
10144   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10145     ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
10146     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10147     break 2
10148   fi
10149 done
10150   done
10151 IFS=$as_save_IFS
10152 
10153   ;;
10154 esac
10155 fi
10156 TOUCH=$ac_cv_path_TOUCH
10157 if test -n "$TOUCH"; then
10158   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
10159 $as_echo "$TOUCH" >&6; }
10160 else
10161   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10162 $as_echo "no" >&6; }
10163 fi
10164 
10165 
10166         if test "x$TOUCH" = x; then
10167           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10168         fi
10169       else
10170         # Otherwise we believe it is a complete path. Use it as it is.
10171         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
10172 $as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
10173         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
10174 $as_echo_n "checking for TOUCH... " >&6; }
10175         if test ! -x "$tool_specified"; then
10176           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10177 $as_echo "not found" >&6; }
10178           as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
10179         fi
10180         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10181 $as_echo "$tool_specified" >&6; }
10182       fi
10183     fi
10184   fi
10185 
10186 
10187 
10188   if test "x$TOUCH" = x; then
10189     as_fn_error $? "Could not find required tool for TOUCH" "$LINENO" 5
10190   fi
10191 
10192 
10193 
10194 
10195 
10196   # Publish this variable in the help.
10197 
10198 
10199   if test "x$TR" = x; then
10200     # The variable is not set by user, try to locate tool using the code snippet
10201     for ac_prog in tr
10202 do
10203   # Extract the first word of "$ac_prog", so it can be a program name with args.
10204 set dummy $ac_prog; ac_word=$2
10205 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10206 $as_echo_n "checking for $ac_word... " >&6; }
10207 if ${ac_cv_path_TR+:} false; then :
10208   $as_echo_n "(cached) " >&6
10209 else
10210   case $TR in
10211   [\\/]* | ?:[\\/]*)
10212   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10213   ;;
10214   *)
10215   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10216 for as_dir in $PATH
10217 do
10218   IFS=$as_save_IFS
10219   test -z "$as_dir" && as_dir=.
10220     for ac_exec_ext in '' $ac_executable_extensions; do
10221   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10222     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10223     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10224     break 2
10225   fi
10226 done
10227   done
10228 IFS=$as_save_IFS
10229 
10230   ;;
10231 esac
10232 fi
10233 TR=$ac_cv_path_TR
10234 if test -n "$TR"; then
10235   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10236 $as_echo "$TR" >&6; }
10237 else
10238   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10239 $as_echo "no" >&6; }
10240 fi
10241 
10242 
10243   test -n "$TR" && break
10244 done
10245 
10246   else
10247     # The variable is set, but is it from the command line or the environment?
10248 
10249     # Try to remove the string !TR! from our list.
10250     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TR!/}
10251     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10252       # If it failed, the variable was not from the command line. Ignore it,
10253       # but warn the user (except for BASH, which is always set by the calling BASH).
10254       if test "xTR" != xBASH; then
10255         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
10256 $as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
10257       fi
10258       # Try to locate tool using the code snippet
10259       for ac_prog in tr
10260 do
10261   # Extract the first word of "$ac_prog", so it can be a program name with args.
10262 set dummy $ac_prog; ac_word=$2
10263 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10264 $as_echo_n "checking for $ac_word... " >&6; }
10265 if ${ac_cv_path_TR+:} false; then :
10266   $as_echo_n "(cached) " >&6
10267 else
10268   case $TR in
10269   [\\/]* | ?:[\\/]*)
10270   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10271   ;;
10272   *)
10273   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10274 for as_dir in $PATH
10275 do
10276   IFS=$as_save_IFS
10277   test -z "$as_dir" && as_dir=.
10278     for ac_exec_ext in '' $ac_executable_extensions; do
10279   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10280     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10281     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10282     break 2
10283   fi
10284 done
10285   done
10286 IFS=$as_save_IFS
10287 
10288   ;;
10289 esac
10290 fi
10291 TR=$ac_cv_path_TR
10292 if test -n "$TR"; then
10293   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10294 $as_echo "$TR" >&6; }
10295 else
10296   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10297 $as_echo "no" >&6; }
10298 fi
10299 
10300 
10301   test -n "$TR" && break
10302 done
10303 
10304     else
10305       # If it succeeded, then it was overridden by the user. We will use it
10306       # for the tool.
10307 
10308       # First remove it from the list of overridden variables, so we can test
10309       # for unknown variables in the end.
10310       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10311 
10312       # Check if the provided tool contains a complete path.
10313       tool_specified="$TR"
10314       tool_basename="${tool_specified##*/}"
10315       if test "x$tool_basename" = "x$tool_specified"; then
10316         # A command without a complete path is provided, search $PATH.
10317         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
10318 $as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
10319         # Extract the first word of "$tool_basename", so it can be a program name with args.
10320 set dummy $tool_basename; ac_word=$2
10321 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10322 $as_echo_n "checking for $ac_word... " >&6; }
10323 if ${ac_cv_path_TR+:} false; then :
10324   $as_echo_n "(cached) " >&6
10325 else
10326   case $TR in
10327   [\\/]* | ?:[\\/]*)
10328   ac_cv_path_TR="$TR" # Let the user override the test with a path.
10329   ;;
10330   *)
10331   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10332 for as_dir in $PATH
10333 do
10334   IFS=$as_save_IFS
10335   test -z "$as_dir" && as_dir=.
10336     for ac_exec_ext in '' $ac_executable_extensions; do
10337   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10338     ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
10339     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10340     break 2
10341   fi
10342 done
10343   done
10344 IFS=$as_save_IFS
10345 
10346   ;;
10347 esac
10348 fi
10349 TR=$ac_cv_path_TR
10350 if test -n "$TR"; then
10351   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
10352 $as_echo "$TR" >&6; }
10353 else
10354   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10355 $as_echo "no" >&6; }
10356 fi
10357 
10358 
10359         if test "x$TR" = x; then
10360           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10361         fi
10362       else
10363         # Otherwise we believe it is a complete path. Use it as it is.
10364         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
10365 $as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
10366         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
10367 $as_echo_n "checking for TR... " >&6; }
10368         if test ! -x "$tool_specified"; then
10369           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10370 $as_echo "not found" >&6; }
10371           as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
10372         fi
10373         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10374 $as_echo "$tool_specified" >&6; }
10375       fi
10376     fi
10377   fi
10378 
10379 
10380 
10381   if test "x$TR" = x; then
10382     as_fn_error $? "Could not find required tool for TR" "$LINENO" 5
10383   fi
10384 
10385 
10386 
10387 
10388 
10389   # Publish this variable in the help.
10390 
10391 
10392   if test "x$UNAME" = x; then
10393     # The variable is not set by user, try to locate tool using the code snippet
10394     for ac_prog in uname
10395 do
10396   # Extract the first word of "$ac_prog", so it can be a program name with args.
10397 set dummy $ac_prog; ac_word=$2
10398 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10399 $as_echo_n "checking for $ac_word... " >&6; }
10400 if ${ac_cv_path_UNAME+:} false; then :
10401   $as_echo_n "(cached) " >&6
10402 else
10403   case $UNAME in
10404   [\\/]* | ?:[\\/]*)
10405   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10406   ;;
10407   *)
10408   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10409 for as_dir in $PATH
10410 do
10411   IFS=$as_save_IFS
10412   test -z "$as_dir" && as_dir=.
10413     for ac_exec_ext in '' $ac_executable_extensions; do
10414   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10415     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10416     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10417     break 2
10418   fi
10419 done
10420   done
10421 IFS=$as_save_IFS
10422 
10423   ;;
10424 esac
10425 fi
10426 UNAME=$ac_cv_path_UNAME
10427 if test -n "$UNAME"; then
10428   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10429 $as_echo "$UNAME" >&6; }
10430 else
10431   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10432 $as_echo "no" >&6; }
10433 fi
10434 
10435 
10436   test -n "$UNAME" && break
10437 done
10438 
10439   else
10440     # The variable is set, but is it from the command line or the environment?
10441 
10442     # Try to remove the string !UNAME! from our list.
10443     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNAME!/}
10444     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10445       # If it failed, the variable was not from the command line. Ignore it,
10446       # but warn the user (except for BASH, which is always set by the calling BASH).
10447       if test "xUNAME" != xBASH; then
10448         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
10449 $as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
10450       fi
10451       # Try to locate tool using the code snippet
10452       for ac_prog in uname
10453 do
10454   # Extract the first word of "$ac_prog", so it can be a program name with args.
10455 set dummy $ac_prog; ac_word=$2
10456 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10457 $as_echo_n "checking for $ac_word... " >&6; }
10458 if ${ac_cv_path_UNAME+:} false; then :
10459   $as_echo_n "(cached) " >&6
10460 else
10461   case $UNAME in
10462   [\\/]* | ?:[\\/]*)
10463   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10464   ;;
10465   *)
10466   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10467 for as_dir in $PATH
10468 do
10469   IFS=$as_save_IFS
10470   test -z "$as_dir" && as_dir=.
10471     for ac_exec_ext in '' $ac_executable_extensions; do
10472   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10473     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10474     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10475     break 2
10476   fi
10477 done
10478   done
10479 IFS=$as_save_IFS
10480 
10481   ;;
10482 esac
10483 fi
10484 UNAME=$ac_cv_path_UNAME
10485 if test -n "$UNAME"; then
10486   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10487 $as_echo "$UNAME" >&6; }
10488 else
10489   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10490 $as_echo "no" >&6; }
10491 fi
10492 
10493 
10494   test -n "$UNAME" && break
10495 done
10496 
10497     else
10498       # If it succeeded, then it was overridden by the user. We will use it
10499       # for the tool.
10500 
10501       # First remove it from the list of overridden variables, so we can test
10502       # for unknown variables in the end.
10503       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10504 
10505       # Check if the provided tool contains a complete path.
10506       tool_specified="$UNAME"
10507       tool_basename="${tool_specified##*/}"
10508       if test "x$tool_basename" = "x$tool_specified"; then
10509         # A command without a complete path is provided, search $PATH.
10510         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
10511 $as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
10512         # Extract the first word of "$tool_basename", so it can be a program name with args.
10513 set dummy $tool_basename; ac_word=$2
10514 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10515 $as_echo_n "checking for $ac_word... " >&6; }
10516 if ${ac_cv_path_UNAME+:} false; then :
10517   $as_echo_n "(cached) " >&6
10518 else
10519   case $UNAME in
10520   [\\/]* | ?:[\\/]*)
10521   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
10522   ;;
10523   *)
10524   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10525 for as_dir in $PATH
10526 do
10527   IFS=$as_save_IFS
10528   test -z "$as_dir" && as_dir=.
10529     for ac_exec_ext in '' $ac_executable_extensions; do
10530   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10531     ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
10532     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10533     break 2
10534   fi
10535 done
10536   done
10537 IFS=$as_save_IFS
10538 
10539   ;;
10540 esac
10541 fi
10542 UNAME=$ac_cv_path_UNAME
10543 if test -n "$UNAME"; then
10544   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
10545 $as_echo "$UNAME" >&6; }
10546 else
10547   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10548 $as_echo "no" >&6; }
10549 fi
10550 
10551 
10552         if test "x$UNAME" = x; then
10553           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10554         fi
10555       else
10556         # Otherwise we believe it is a complete path. Use it as it is.
10557         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
10558 $as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
10559         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
10560 $as_echo_n "checking for UNAME... " >&6; }
10561         if test ! -x "$tool_specified"; then
10562           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10563 $as_echo "not found" >&6; }
10564           as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
10565         fi
10566         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10567 $as_echo "$tool_specified" >&6; }
10568       fi
10569     fi
10570   fi
10571 
10572 
10573 
10574   if test "x$UNAME" = x; then
10575     as_fn_error $? "Could not find required tool for UNAME" "$LINENO" 5
10576   fi
10577 
10578 
10579 
10580 
10581 
10582   # Publish this variable in the help.
10583 
10584 
10585   if test "x$UNIQ" = x; then
10586     # The variable is not set by user, try to locate tool using the code snippet
10587     for ac_prog in uniq
10588 do
10589   # Extract the first word of "$ac_prog", so it can be a program name with args.
10590 set dummy $ac_prog; ac_word=$2
10591 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10592 $as_echo_n "checking for $ac_word... " >&6; }
10593 if ${ac_cv_path_UNIQ+:} false; then :
10594   $as_echo_n "(cached) " >&6
10595 else
10596   case $UNIQ in
10597   [\\/]* | ?:[\\/]*)
10598   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10599   ;;
10600   *)
10601   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10602 for as_dir in $PATH
10603 do
10604   IFS=$as_save_IFS
10605   test -z "$as_dir" && as_dir=.
10606     for ac_exec_ext in '' $ac_executable_extensions; do
10607   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10608     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10609     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10610     break 2
10611   fi
10612 done
10613   done
10614 IFS=$as_save_IFS
10615 
10616   ;;
10617 esac
10618 fi
10619 UNIQ=$ac_cv_path_UNIQ
10620 if test -n "$UNIQ"; then
10621   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10622 $as_echo "$UNIQ" >&6; }
10623 else
10624   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10625 $as_echo "no" >&6; }
10626 fi
10627 
10628 
10629   test -n "$UNIQ" && break
10630 done
10631 
10632   else
10633     # The variable is set, but is it from the command line or the environment?
10634 
10635     # Try to remove the string !UNIQ! from our list.
10636     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNIQ!/}
10637     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10638       # If it failed, the variable was not from the command line. Ignore it,
10639       # but warn the user (except for BASH, which is always set by the calling BASH).
10640       if test "xUNIQ" != xBASH; then
10641         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
10642 $as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
10643       fi
10644       # Try to locate tool using the code snippet
10645       for ac_prog in uniq
10646 do
10647   # Extract the first word of "$ac_prog", so it can be a program name with args.
10648 set dummy $ac_prog; ac_word=$2
10649 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10650 $as_echo_n "checking for $ac_word... " >&6; }
10651 if ${ac_cv_path_UNIQ+:} false; then :
10652   $as_echo_n "(cached) " >&6
10653 else
10654   case $UNIQ in
10655   [\\/]* | ?:[\\/]*)
10656   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10657   ;;
10658   *)
10659   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10660 for as_dir in $PATH
10661 do
10662   IFS=$as_save_IFS
10663   test -z "$as_dir" && as_dir=.
10664     for ac_exec_ext in '' $ac_executable_extensions; do
10665   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10666     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10667     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10668     break 2
10669   fi
10670 done
10671   done
10672 IFS=$as_save_IFS
10673 
10674   ;;
10675 esac
10676 fi
10677 UNIQ=$ac_cv_path_UNIQ
10678 if test -n "$UNIQ"; then
10679   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10680 $as_echo "$UNIQ" >&6; }
10681 else
10682   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10683 $as_echo "no" >&6; }
10684 fi
10685 
10686 
10687   test -n "$UNIQ" && break
10688 done
10689 
10690     else
10691       # If it succeeded, then it was overridden by the user. We will use it
10692       # for the tool.
10693 
10694       # First remove it from the list of overridden variables, so we can test
10695       # for unknown variables in the end.
10696       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10697 
10698       # Check if the provided tool contains a complete path.
10699       tool_specified="$UNIQ"
10700       tool_basename="${tool_specified##*/}"
10701       if test "x$tool_basename" = "x$tool_specified"; then
10702         # A command without a complete path is provided, search $PATH.
10703         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
10704 $as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
10705         # Extract the first word of "$tool_basename", so it can be a program name with args.
10706 set dummy $tool_basename; ac_word=$2
10707 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10708 $as_echo_n "checking for $ac_word... " >&6; }
10709 if ${ac_cv_path_UNIQ+:} false; then :
10710   $as_echo_n "(cached) " >&6
10711 else
10712   case $UNIQ in
10713   [\\/]* | ?:[\\/]*)
10714   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
10715   ;;
10716   *)
10717   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10718 for as_dir in $PATH
10719 do
10720   IFS=$as_save_IFS
10721   test -z "$as_dir" && as_dir=.
10722     for ac_exec_ext in '' $ac_executable_extensions; do
10723   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10724     ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
10725     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10726     break 2
10727   fi
10728 done
10729   done
10730 IFS=$as_save_IFS
10731 
10732   ;;
10733 esac
10734 fi
10735 UNIQ=$ac_cv_path_UNIQ
10736 if test -n "$UNIQ"; then
10737   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
10738 $as_echo "$UNIQ" >&6; }
10739 else
10740   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10741 $as_echo "no" >&6; }
10742 fi
10743 
10744 
10745         if test "x$UNIQ" = x; then
10746           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10747         fi
10748       else
10749         # Otherwise we believe it is a complete path. Use it as it is.
10750         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
10751 $as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
10752         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
10753 $as_echo_n "checking for UNIQ... " >&6; }
10754         if test ! -x "$tool_specified"; then
10755           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10756 $as_echo "not found" >&6; }
10757           as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
10758         fi
10759         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10760 $as_echo "$tool_specified" >&6; }
10761       fi
10762     fi
10763   fi
10764 
10765 
10766 
10767   if test "x$UNIQ" = x; then
10768     as_fn_error $? "Could not find required tool for UNIQ" "$LINENO" 5
10769   fi
10770 
10771 
10772 
10773 
10774 
10775   # Publish this variable in the help.
10776 
10777 
10778   if test "x$WC" = x; then
10779     # The variable is not set by user, try to locate tool using the code snippet
10780     for ac_prog in wc
10781 do
10782   # Extract the first word of "$ac_prog", so it can be a program name with args.
10783 set dummy $ac_prog; ac_word=$2
10784 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10785 $as_echo_n "checking for $ac_word... " >&6; }
10786 if ${ac_cv_path_WC+:} false; then :
10787   $as_echo_n "(cached) " >&6
10788 else
10789   case $WC in
10790   [\\/]* | ?:[\\/]*)
10791   ac_cv_path_WC="$WC" # Let the user override the test with a path.
10792   ;;
10793   *)
10794   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10795 for as_dir in $PATH
10796 do
10797   IFS=$as_save_IFS
10798   test -z "$as_dir" && as_dir=.
10799     for ac_exec_ext in '' $ac_executable_extensions; do
10800   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10801     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10802     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10803     break 2
10804   fi
10805 done
10806   done
10807 IFS=$as_save_IFS
10808 
10809   ;;
10810 esac
10811 fi
10812 WC=$ac_cv_path_WC
10813 if test -n "$WC"; then
10814   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10815 $as_echo "$WC" >&6; }
10816 else
10817   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10818 $as_echo "no" >&6; }
10819 fi
10820 
10821 
10822   test -n "$WC" && break
10823 done
10824 
10825   else
10826     # The variable is set, but is it from the command line or the environment?
10827 
10828     # Try to remove the string !WC! from our list.
10829     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WC!/}
10830     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
10831       # If it failed, the variable was not from the command line. Ignore it,
10832       # but warn the user (except for BASH, which is always set by the calling BASH).
10833       if test "xWC" != xBASH; then
10834         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
10835 $as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
10836       fi
10837       # Try to locate tool using the code snippet
10838       for ac_prog in wc
10839 do
10840   # Extract the first word of "$ac_prog", so it can be a program name with args.
10841 set dummy $ac_prog; ac_word=$2
10842 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10843 $as_echo_n "checking for $ac_word... " >&6; }
10844 if ${ac_cv_path_WC+:} false; then :
10845   $as_echo_n "(cached) " >&6
10846 else
10847   case $WC in
10848   [\\/]* | ?:[\\/]*)
10849   ac_cv_path_WC="$WC" # Let the user override the test with a path.
10850   ;;
10851   *)
10852   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10853 for as_dir in $PATH
10854 do
10855   IFS=$as_save_IFS
10856   test -z "$as_dir" && as_dir=.
10857     for ac_exec_ext in '' $ac_executable_extensions; do
10858   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10859     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10860     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10861     break 2
10862   fi
10863 done
10864   done
10865 IFS=$as_save_IFS
10866 
10867   ;;
10868 esac
10869 fi
10870 WC=$ac_cv_path_WC
10871 if test -n "$WC"; then
10872   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10873 $as_echo "$WC" >&6; }
10874 else
10875   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10876 $as_echo "no" >&6; }
10877 fi
10878 
10879 
10880   test -n "$WC" && break
10881 done
10882 
10883     else
10884       # If it succeeded, then it was overridden by the user. We will use it
10885       # for the tool.
10886 
10887       # First remove it from the list of overridden variables, so we can test
10888       # for unknown variables in the end.
10889       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
10890 
10891       # Check if the provided tool contains a complete path.
10892       tool_specified="$WC"
10893       tool_basename="${tool_specified##*/}"
10894       if test "x$tool_basename" = "x$tool_specified"; then
10895         # A command without a complete path is provided, search $PATH.
10896         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
10897 $as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
10898         # Extract the first word of "$tool_basename", so it can be a program name with args.
10899 set dummy $tool_basename; ac_word=$2
10900 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10901 $as_echo_n "checking for $ac_word... " >&6; }
10902 if ${ac_cv_path_WC+:} false; then :
10903   $as_echo_n "(cached) " >&6
10904 else
10905   case $WC in
10906   [\\/]* | ?:[\\/]*)
10907   ac_cv_path_WC="$WC" # Let the user override the test with a path.
10908   ;;
10909   *)
10910   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10911 for as_dir in $PATH
10912 do
10913   IFS=$as_save_IFS
10914   test -z "$as_dir" && as_dir=.
10915     for ac_exec_ext in '' $ac_executable_extensions; do
10916   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10917     ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
10918     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10919     break 2
10920   fi
10921 done
10922   done
10923 IFS=$as_save_IFS
10924 
10925   ;;
10926 esac
10927 fi
10928 WC=$ac_cv_path_WC
10929 if test -n "$WC"; then
10930   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
10931 $as_echo "$WC" >&6; }
10932 else
10933   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10934 $as_echo "no" >&6; }
10935 fi
10936 
10937 
10938         if test "x$WC" = x; then
10939           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
10940         fi
10941       else
10942         # Otherwise we believe it is a complete path. Use it as it is.
10943         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
10944 $as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
10945         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
10946 $as_echo_n "checking for WC... " >&6; }
10947         if test ! -x "$tool_specified"; then
10948           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
10949 $as_echo "not found" >&6; }
10950           as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
10951         fi
10952         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
10953 $as_echo "$tool_specified" >&6; }
10954       fi
10955     fi
10956   fi
10957 
10958 
10959 
10960   if test "x$WC" = x; then
10961     as_fn_error $? "Could not find required tool for WC" "$LINENO" 5
10962   fi
10963 
10964 
10965 
10966 
10967 
10968   # Publish this variable in the help.
10969 
10970 
10971   if test "x$WHICH" = x; then
10972     # The variable is not set by user, try to locate tool using the code snippet
10973     for ac_prog in which
10974 do
10975   # Extract the first word of "$ac_prog", so it can be a program name with args.
10976 set dummy $ac_prog; ac_word=$2
10977 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10978 $as_echo_n "checking for $ac_word... " >&6; }
10979 if ${ac_cv_path_WHICH+:} false; then :
10980   $as_echo_n "(cached) " >&6
10981 else
10982   case $WHICH in
10983   [\\/]* | ?:[\\/]*)
10984   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
10985   ;;
10986   *)
10987   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10988 for as_dir in $PATH
10989 do
10990   IFS=$as_save_IFS
10991   test -z "$as_dir" && as_dir=.
10992     for ac_exec_ext in '' $ac_executable_extensions; do
10993   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10994     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
10995     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10996     break 2
10997   fi
10998 done
10999   done
11000 IFS=$as_save_IFS
11001 
11002   ;;
11003 esac
11004 fi
11005 WHICH=$ac_cv_path_WHICH
11006 if test -n "$WHICH"; then
11007   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11008 $as_echo "$WHICH" >&6; }
11009 else
11010   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11011 $as_echo "no" >&6; }
11012 fi
11013 
11014 
11015   test -n "$WHICH" && break
11016 done
11017 
11018   else
11019     # The variable is set, but is it from the command line or the environment?
11020 
11021     # Try to remove the string !WHICH! from our list.
11022     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!WHICH!/}
11023     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11024       # If it failed, the variable was not from the command line. Ignore it,
11025       # but warn the user (except for BASH, which is always set by the calling BASH).
11026       if test "xWHICH" != xBASH; then
11027         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
11028 $as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
11029       fi
11030       # Try to locate tool using the code snippet
11031       for ac_prog in which
11032 do
11033   # Extract the first word of "$ac_prog", so it can be a program name with args.
11034 set dummy $ac_prog; ac_word=$2
11035 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11036 $as_echo_n "checking for $ac_word... " >&6; }
11037 if ${ac_cv_path_WHICH+:} false; then :
11038   $as_echo_n "(cached) " >&6
11039 else
11040   case $WHICH in
11041   [\\/]* | ?:[\\/]*)
11042   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11043   ;;
11044   *)
11045   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11046 for as_dir in $PATH
11047 do
11048   IFS=$as_save_IFS
11049   test -z "$as_dir" && as_dir=.
11050     for ac_exec_ext in '' $ac_executable_extensions; do
11051   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11052     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11053     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11054     break 2
11055   fi
11056 done
11057   done
11058 IFS=$as_save_IFS
11059 
11060   ;;
11061 esac
11062 fi
11063 WHICH=$ac_cv_path_WHICH
11064 if test -n "$WHICH"; then
11065   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11066 $as_echo "$WHICH" >&6; }
11067 else
11068   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11069 $as_echo "no" >&6; }
11070 fi
11071 
11072 
11073   test -n "$WHICH" && break
11074 done
11075 
11076     else
11077       # If it succeeded, then it was overridden by the user. We will use it
11078       # for the tool.
11079 
11080       # First remove it from the list of overridden variables, so we can test
11081       # for unknown variables in the end.
11082       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11083 
11084       # Check if the provided tool contains a complete path.
11085       tool_specified="$WHICH"
11086       tool_basename="${tool_specified##*/}"
11087       if test "x$tool_basename" = "x$tool_specified"; then
11088         # A command without a complete path is provided, search $PATH.
11089         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
11090 $as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
11091         # Extract the first word of "$tool_basename", so it can be a program name with args.
11092 set dummy $tool_basename; ac_word=$2
11093 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11094 $as_echo_n "checking for $ac_word... " >&6; }
11095 if ${ac_cv_path_WHICH+:} false; then :
11096   $as_echo_n "(cached) " >&6
11097 else
11098   case $WHICH in
11099   [\\/]* | ?:[\\/]*)
11100   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
11101   ;;
11102   *)
11103   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11104 for as_dir in $PATH
11105 do
11106   IFS=$as_save_IFS
11107   test -z "$as_dir" && as_dir=.
11108     for ac_exec_ext in '' $ac_executable_extensions; do
11109   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11110     ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
11111     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11112     break 2
11113   fi
11114 done
11115   done
11116 IFS=$as_save_IFS
11117 
11118   ;;
11119 esac
11120 fi
11121 WHICH=$ac_cv_path_WHICH
11122 if test -n "$WHICH"; then
11123   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
11124 $as_echo "$WHICH" >&6; }
11125 else
11126   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11127 $as_echo "no" >&6; }
11128 fi
11129 
11130 
11131         if test "x$WHICH" = x; then
11132           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11133         fi
11134       else
11135         # Otherwise we believe it is a complete path. Use it as it is.
11136         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
11137 $as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
11138         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
11139 $as_echo_n "checking for WHICH... " >&6; }
11140         if test ! -x "$tool_specified"; then
11141           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11142 $as_echo "not found" >&6; }
11143           as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
11144         fi
11145         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11146 $as_echo "$tool_specified" >&6; }
11147       fi
11148     fi
11149   fi
11150 
11151 
11152 
11153   if test "x$WHICH" = x; then
11154     as_fn_error $? "Could not find required tool for WHICH" "$LINENO" 5
11155   fi
11156 
11157 
11158 
11159 
11160 
11161   # Publish this variable in the help.
11162 
11163 
11164   if test "x$XARGS" = x; then
11165     # The variable is not set by user, try to locate tool using the code snippet
11166     for ac_prog in xargs
11167 do
11168   # Extract the first word of "$ac_prog", so it can be a program name with args.
11169 set dummy $ac_prog; ac_word=$2
11170 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11171 $as_echo_n "checking for $ac_word... " >&6; }
11172 if ${ac_cv_path_XARGS+:} false; then :
11173   $as_echo_n "(cached) " >&6
11174 else
11175   case $XARGS in
11176   [\\/]* | ?:[\\/]*)
11177   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11178   ;;
11179   *)
11180   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11181 for as_dir in $PATH
11182 do
11183   IFS=$as_save_IFS
11184   test -z "$as_dir" && as_dir=.
11185     for ac_exec_ext in '' $ac_executable_extensions; do
11186   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11187     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11188     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11189     break 2
11190   fi
11191 done
11192   done
11193 IFS=$as_save_IFS
11194 
11195   ;;
11196 esac
11197 fi
11198 XARGS=$ac_cv_path_XARGS
11199 if test -n "$XARGS"; then
11200   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11201 $as_echo "$XARGS" >&6; }
11202 else
11203   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11204 $as_echo "no" >&6; }
11205 fi
11206 
11207 
11208   test -n "$XARGS" && break
11209 done
11210 
11211   else
11212     # The variable is set, but is it from the command line or the environment?
11213 
11214     # Try to remove the string !XARGS! from our list.
11215     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XARGS!/}
11216     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11217       # If it failed, the variable was not from the command line. Ignore it,
11218       # but warn the user (except for BASH, which is always set by the calling BASH).
11219       if test "xXARGS" != xBASH; then
11220         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
11221 $as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
11222       fi
11223       # Try to locate tool using the code snippet
11224       for ac_prog in xargs
11225 do
11226   # Extract the first word of "$ac_prog", so it can be a program name with args.
11227 set dummy $ac_prog; ac_word=$2
11228 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11229 $as_echo_n "checking for $ac_word... " >&6; }
11230 if ${ac_cv_path_XARGS+:} false; then :
11231   $as_echo_n "(cached) " >&6
11232 else
11233   case $XARGS in
11234   [\\/]* | ?:[\\/]*)
11235   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11236   ;;
11237   *)
11238   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11239 for as_dir in $PATH
11240 do
11241   IFS=$as_save_IFS
11242   test -z "$as_dir" && as_dir=.
11243     for ac_exec_ext in '' $ac_executable_extensions; do
11244   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11245     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11246     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11247     break 2
11248   fi
11249 done
11250   done
11251 IFS=$as_save_IFS
11252 
11253   ;;
11254 esac
11255 fi
11256 XARGS=$ac_cv_path_XARGS
11257 if test -n "$XARGS"; then
11258   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11259 $as_echo "$XARGS" >&6; }
11260 else
11261   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11262 $as_echo "no" >&6; }
11263 fi
11264 
11265 
11266   test -n "$XARGS" && break
11267 done
11268 
11269     else
11270       # If it succeeded, then it was overridden by the user. We will use it
11271       # for the tool.
11272 
11273       # First remove it from the list of overridden variables, so we can test
11274       # for unknown variables in the end.
11275       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11276 
11277       # Check if the provided tool contains a complete path.
11278       tool_specified="$XARGS"
11279       tool_basename="${tool_specified##*/}"
11280       if test "x$tool_basename" = "x$tool_specified"; then
11281         # A command without a complete path is provided, search $PATH.
11282         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
11283 $as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
11284         # Extract the first word of "$tool_basename", so it can be a program name with args.
11285 set dummy $tool_basename; ac_word=$2
11286 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11287 $as_echo_n "checking for $ac_word... " >&6; }
11288 if ${ac_cv_path_XARGS+:} false; then :
11289   $as_echo_n "(cached) " >&6
11290 else
11291   case $XARGS in
11292   [\\/]* | ?:[\\/]*)
11293   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
11294   ;;
11295   *)
11296   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11297 for as_dir in $PATH
11298 do
11299   IFS=$as_save_IFS
11300   test -z "$as_dir" && as_dir=.
11301     for ac_exec_ext in '' $ac_executable_extensions; do
11302   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11303     ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
11304     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11305     break 2
11306   fi
11307 done
11308   done
11309 IFS=$as_save_IFS
11310 
11311   ;;
11312 esac
11313 fi
11314 XARGS=$ac_cv_path_XARGS
11315 if test -n "$XARGS"; then
11316   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
11317 $as_echo "$XARGS" >&6; }
11318 else
11319   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11320 $as_echo "no" >&6; }
11321 fi
11322 
11323 
11324         if test "x$XARGS" = x; then
11325           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11326         fi
11327       else
11328         # Otherwise we believe it is a complete path. Use it as it is.
11329         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
11330 $as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
11331         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
11332 $as_echo_n "checking for XARGS... " >&6; }
11333         if test ! -x "$tool_specified"; then
11334           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11335 $as_echo "not found" >&6; }
11336           as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
11337         fi
11338         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11339 $as_echo "$tool_specified" >&6; }
11340       fi
11341     fi
11342   fi
11343 
11344 
11345 
11346   if test "x$XARGS" = x; then
11347     as_fn_error $? "Could not find required tool for XARGS" "$LINENO" 5
11348   fi
11349 
11350 
11351 
11352   # Then required tools that require some special treatment.
11353 
11354 
11355   # Publish this variable in the help.
11356 
11357 
11358   if test "x$AWK" = x; then
11359     # The variable is not set by user, try to locate tool using the code snippet
11360     for ac_prog in gawk mawk nawk awk
11361 do
11362   # Extract the first word of "$ac_prog", so it can be a program name with args.
11363 set dummy $ac_prog; ac_word=$2
11364 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11365 $as_echo_n "checking for $ac_word... " >&6; }
11366 if ${ac_cv_prog_AWK+:} false; then :
11367   $as_echo_n "(cached) " >&6
11368 else
11369   if test -n "$AWK"; then
11370   ac_cv_prog_AWK="$AWK" # Let the user override the test.
11371 else
11372 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11373 for as_dir in $PATH
11374 do
11375   IFS=$as_save_IFS
11376   test -z "$as_dir" && as_dir=.
11377     for ac_exec_ext in '' $ac_executable_extensions; do
11378   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11379     ac_cv_prog_AWK="$ac_prog"
11380     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11381     break 2
11382   fi
11383 done
11384   done
11385 IFS=$as_save_IFS
11386 
11387 fi
11388 fi
11389 AWK=$ac_cv_prog_AWK
11390 if test -n "$AWK"; then
11391   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11392 $as_echo "$AWK" >&6; }
11393 else
11394   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11395 $as_echo "no" >&6; }
11396 fi
11397 
11398 
11399   test -n "$AWK" && break
11400 done
11401 
11402   else
11403     # The variable is set, but is it from the command line or the environment?
11404 
11405     # Try to remove the string !AWK! from our list.
11406     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!AWK!/}
11407     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11408       # If it failed, the variable was not from the command line. Ignore it,
11409       # but warn the user (except for BASH, which is always set by the calling BASH).
11410       if test "xAWK" != xBASH; then
11411         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
11412 $as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
11413       fi
11414       # Try to locate tool using the code snippet
11415       for ac_prog in gawk mawk nawk awk
11416 do
11417   # Extract the first word of "$ac_prog", so it can be a program name with args.
11418 set dummy $ac_prog; ac_word=$2
11419 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11420 $as_echo_n "checking for $ac_word... " >&6; }
11421 if ${ac_cv_prog_AWK+:} false; then :
11422   $as_echo_n "(cached) " >&6
11423 else
11424   if test -n "$AWK"; then
11425   ac_cv_prog_AWK="$AWK" # Let the user override the test.
11426 else
11427 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11428 for as_dir in $PATH
11429 do
11430   IFS=$as_save_IFS
11431   test -z "$as_dir" && as_dir=.
11432     for ac_exec_ext in '' $ac_executable_extensions; do
11433   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11434     ac_cv_prog_AWK="$ac_prog"
11435     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11436     break 2
11437   fi
11438 done
11439   done
11440 IFS=$as_save_IFS
11441 
11442 fi
11443 fi
11444 AWK=$ac_cv_prog_AWK
11445 if test -n "$AWK"; then
11446   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11447 $as_echo "$AWK" >&6; }
11448 else
11449   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11450 $as_echo "no" >&6; }
11451 fi
11452 
11453 
11454   test -n "$AWK" && break
11455 done
11456 
11457     else
11458       # If it succeeded, then it was overridden by the user. We will use it
11459       # for the tool.
11460 
11461       # First remove it from the list of overridden variables, so we can test
11462       # for unknown variables in the end.
11463       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11464 
11465       # Check if the provided tool contains a complete path.
11466       tool_specified="$AWK"
11467       tool_basename="${tool_specified##*/}"
11468       if test "x$tool_basename" = "x$tool_specified"; then
11469         # A command without a complete path is provided, search $PATH.
11470         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
11471 $as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
11472         # Extract the first word of "$tool_basename", so it can be a program name with args.
11473 set dummy $tool_basename; ac_word=$2
11474 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11475 $as_echo_n "checking for $ac_word... " >&6; }
11476 if ${ac_cv_path_AWK+:} false; then :
11477   $as_echo_n "(cached) " >&6
11478 else
11479   case $AWK in
11480   [\\/]* | ?:[\\/]*)
11481   ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
11482   ;;
11483   *)
11484   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11485 for as_dir in $PATH
11486 do
11487   IFS=$as_save_IFS
11488   test -z "$as_dir" && as_dir=.
11489     for ac_exec_ext in '' $ac_executable_extensions; do
11490   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11491     ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
11492     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11493     break 2
11494   fi
11495 done
11496   done
11497 IFS=$as_save_IFS
11498 
11499   ;;
11500 esac
11501 fi
11502 AWK=$ac_cv_path_AWK
11503 if test -n "$AWK"; then
11504   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
11505 $as_echo "$AWK" >&6; }
11506 else
11507   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11508 $as_echo "no" >&6; }
11509 fi
11510 
11511 
11512         if test "x$AWK" = x; then
11513           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11514         fi
11515       else
11516         # Otherwise we believe it is a complete path. Use it as it is.
11517         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
11518 $as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
11519         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
11520 $as_echo_n "checking for AWK... " >&6; }
11521         if test ! -x "$tool_specified"; then
11522           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11523 $as_echo "not found" >&6; }
11524           as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
11525         fi
11526         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11527 $as_echo "$tool_specified" >&6; }
11528       fi
11529     fi
11530   fi
11531 
11532 
11533   if test "x$AWK" = x; then
11534     as_fn_error $? "Could not find required tool for AWK" "$LINENO" 5
11535   fi
11536 
11537 
11538 
11539 
11540   # Publish this variable in the help.
11541 
11542 
11543   if test "x$GREP" = x; then
11544     # The variable is not set by user, try to locate tool using the code snippet
11545     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11546 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11547 if ${ac_cv_path_GREP+:} false; then :
11548   $as_echo_n "(cached) " >&6
11549 else
11550   if test -z "$GREP"; then
11551   ac_path_GREP_found=false
11552   # Loop through the user's path and test for each of PROGNAME-LIST
11553   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11554 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11555 do
11556   IFS=$as_save_IFS
11557   test -z "$as_dir" && as_dir=.
11558     for ac_prog in grep ggrep; do
11559     for ac_exec_ext in '' $ac_executable_extensions; do
11560       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11561       as_fn_executable_p "$ac_path_GREP" || continue
11562 # Check for GNU ac_path_GREP and select it if it is found.
11563   # Check for GNU $ac_path_GREP
11564 case `"$ac_path_GREP" --version 2>&1` in
11565 *GNU*)
11566   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11567 *)
11568   ac_count=0
11569   $as_echo_n 0123456789 >"conftest.in"
11570   while :
11571   do
11572     cat "conftest.in" "conftest.in" >"conftest.tmp"
11573     mv "conftest.tmp" "conftest.in"
11574     cp "conftest.in" "conftest.nl"
11575     $as_echo 'GREP' >> "conftest.nl"
11576     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11577     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11578     as_fn_arith $ac_count + 1 && ac_count=$as_val
11579     if test $ac_count -gt ${ac_path_GREP_max-0}; then
11580       # Best one so far, save it but keep looking for a better one
11581       ac_cv_path_GREP="$ac_path_GREP"
11582       ac_path_GREP_max=$ac_count
11583     fi
11584     # 10*(2^10) chars as input seems more than enough
11585     test $ac_count -gt 10 && break
11586   done
11587   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11588 esac
11589 
11590       $ac_path_GREP_found && break 3
11591     done
11592   done
11593   done
11594 IFS=$as_save_IFS
11595   if test -z "$ac_cv_path_GREP"; then
11596     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11597   fi
11598 else
11599   ac_cv_path_GREP=$GREP
11600 fi
11601 
11602 fi
11603 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11604 $as_echo "$ac_cv_path_GREP" >&6; }
11605  GREP="$ac_cv_path_GREP"
11606 
11607 
11608   else
11609     # The variable is set, but is it from the command line or the environment?
11610 
11611     # Try to remove the string !GREP! from our list.
11612     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!GREP!/}
11613     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11614       # If it failed, the variable was not from the command line. Ignore it,
11615       # but warn the user (except for BASH, which is always set by the calling BASH).
11616       if test "xGREP" != xBASH; then
11617         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
11618 $as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
11619       fi
11620       # Try to locate tool using the code snippet
11621       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
11622 $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
11623 if ${ac_cv_path_GREP+:} false; then :
11624   $as_echo_n "(cached) " >&6
11625 else
11626   if test -z "$GREP"; then
11627   ac_path_GREP_found=false
11628   # Loop through the user's path and test for each of PROGNAME-LIST
11629   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11630 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11631 do
11632   IFS=$as_save_IFS
11633   test -z "$as_dir" && as_dir=.
11634     for ac_prog in grep ggrep; do
11635     for ac_exec_ext in '' $ac_executable_extensions; do
11636       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
11637       as_fn_executable_p "$ac_path_GREP" || continue
11638 # Check for GNU ac_path_GREP and select it if it is found.
11639   # Check for GNU $ac_path_GREP
11640 case `"$ac_path_GREP" --version 2>&1` in
11641 *GNU*)
11642   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
11643 *)
11644   ac_count=0
11645   $as_echo_n 0123456789 >"conftest.in"
11646   while :
11647   do
11648     cat "conftest.in" "conftest.in" >"conftest.tmp"
11649     mv "conftest.tmp" "conftest.in"
11650     cp "conftest.in" "conftest.nl"
11651     $as_echo 'GREP' >> "conftest.nl"
11652     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11653     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11654     as_fn_arith $ac_count + 1 && ac_count=$as_val
11655     if test $ac_count -gt ${ac_path_GREP_max-0}; then
11656       # Best one so far, save it but keep looking for a better one
11657       ac_cv_path_GREP="$ac_path_GREP"
11658       ac_path_GREP_max=$ac_count
11659     fi
11660     # 10*(2^10) chars as input seems more than enough
11661     test $ac_count -gt 10 && break
11662   done
11663   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11664 esac
11665 
11666       $ac_path_GREP_found && break 3
11667     done
11668   done
11669   done
11670 IFS=$as_save_IFS
11671   if test -z "$ac_cv_path_GREP"; then
11672     as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11673   fi
11674 else
11675   ac_cv_path_GREP=$GREP
11676 fi
11677 
11678 fi
11679 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
11680 $as_echo "$ac_cv_path_GREP" >&6; }
11681  GREP="$ac_cv_path_GREP"
11682 
11683 
11684     else
11685       # If it succeeded, then it was overridden by the user. We will use it
11686       # for the tool.
11687 
11688       # First remove it from the list of overridden variables, so we can test
11689       # for unknown variables in the end.
11690       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11691 
11692       # Check if the provided tool contains a complete path.
11693       tool_specified="$GREP"
11694       tool_basename="${tool_specified##*/}"
11695       if test "x$tool_basename" = "x$tool_specified"; then
11696         # A command without a complete path is provided, search $PATH.
11697         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
11698 $as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
11699         # Extract the first word of "$tool_basename", so it can be a program name with args.
11700 set dummy $tool_basename; ac_word=$2
11701 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11702 $as_echo_n "checking for $ac_word... " >&6; }
11703 if ${ac_cv_path_GREP+:} false; then :
11704   $as_echo_n "(cached) " >&6
11705 else
11706   case $GREP in
11707   [\\/]* | ?:[\\/]*)
11708   ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
11709   ;;
11710   *)
11711   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11712 for as_dir in $PATH
11713 do
11714   IFS=$as_save_IFS
11715   test -z "$as_dir" && as_dir=.
11716     for ac_exec_ext in '' $ac_executable_extensions; do
11717   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11718     ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
11719     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11720     break 2
11721   fi
11722 done
11723   done
11724 IFS=$as_save_IFS
11725 
11726   ;;
11727 esac
11728 fi
11729 GREP=$ac_cv_path_GREP
11730 if test -n "$GREP"; then
11731   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
11732 $as_echo "$GREP" >&6; }
11733 else
11734   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11735 $as_echo "no" >&6; }
11736 fi
11737 
11738 
11739         if test "x$GREP" = x; then
11740           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11741         fi
11742       else
11743         # Otherwise we believe it is a complete path. Use it as it is.
11744         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
11745 $as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
11746         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
11747 $as_echo_n "checking for GREP... " >&6; }
11748         if test ! -x "$tool_specified"; then
11749           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11750 $as_echo "not found" >&6; }
11751           as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
11752         fi
11753         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11754 $as_echo "$tool_specified" >&6; }
11755       fi
11756     fi
11757   fi
11758 
11759 
11760   if test "x$GREP" = x; then
11761     as_fn_error $? "Could not find required tool for GREP" "$LINENO" 5
11762   fi
11763 
11764 
11765 
11766 
11767   # Publish this variable in the help.
11768 
11769 
11770   if test "x$EGREP" = x; then
11771     # The variable is not set by user, try to locate tool using the code snippet
11772     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11773 $as_echo_n "checking for egrep... " >&6; }
11774 if ${ac_cv_path_EGREP+:} false; then :
11775   $as_echo_n "(cached) " >&6
11776 else
11777   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11778    then ac_cv_path_EGREP="$GREP -E"
11779    else
11780      if test -z "$EGREP"; then
11781   ac_path_EGREP_found=false
11782   # Loop through the user's path and test for each of PROGNAME-LIST
11783   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11784 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11785 do
11786   IFS=$as_save_IFS
11787   test -z "$as_dir" && as_dir=.
11788     for ac_prog in egrep; do
11789     for ac_exec_ext in '' $ac_executable_extensions; do
11790       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11791       as_fn_executable_p "$ac_path_EGREP" || continue
11792 # Check for GNU ac_path_EGREP and select it if it is found.
11793   # Check for GNU $ac_path_EGREP
11794 case `"$ac_path_EGREP" --version 2>&1` in
11795 *GNU*)
11796   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11797 *)
11798   ac_count=0
11799   $as_echo_n 0123456789 >"conftest.in"
11800   while :
11801   do
11802     cat "conftest.in" "conftest.in" >"conftest.tmp"
11803     mv "conftest.tmp" "conftest.in"
11804     cp "conftest.in" "conftest.nl"
11805     $as_echo 'EGREP' >> "conftest.nl"
11806     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11807     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11808     as_fn_arith $ac_count + 1 && ac_count=$as_val
11809     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11810       # Best one so far, save it but keep looking for a better one
11811       ac_cv_path_EGREP="$ac_path_EGREP"
11812       ac_path_EGREP_max=$ac_count
11813     fi
11814     # 10*(2^10) chars as input seems more than enough
11815     test $ac_count -gt 10 && break
11816   done
11817   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11818 esac
11819 
11820       $ac_path_EGREP_found && break 3
11821     done
11822   done
11823   done
11824 IFS=$as_save_IFS
11825   if test -z "$ac_cv_path_EGREP"; then
11826     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11827   fi
11828 else
11829   ac_cv_path_EGREP=$EGREP
11830 fi
11831 
11832    fi
11833 fi
11834 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11835 $as_echo "$ac_cv_path_EGREP" >&6; }
11836  EGREP="$ac_cv_path_EGREP"
11837 
11838 
11839   else
11840     # The variable is set, but is it from the command line or the environment?
11841 
11842     # Try to remove the string !EGREP! from our list.
11843     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!EGREP!/}
11844     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
11845       # If it failed, the variable was not from the command line. Ignore it,
11846       # but warn the user (except for BASH, which is always set by the calling BASH).
11847       if test "xEGREP" != xBASH; then
11848         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
11849 $as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
11850       fi
11851       # Try to locate tool using the code snippet
11852       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
11853 $as_echo_n "checking for egrep... " >&6; }
11854 if ${ac_cv_path_EGREP+:} false; then :
11855   $as_echo_n "(cached) " >&6
11856 else
11857   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
11858    then ac_cv_path_EGREP="$GREP -E"
11859    else
11860      if test -z "$EGREP"; then
11861   ac_path_EGREP_found=false
11862   # Loop through the user's path and test for each of PROGNAME-LIST
11863   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11864 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
11865 do
11866   IFS=$as_save_IFS
11867   test -z "$as_dir" && as_dir=.
11868     for ac_prog in egrep; do
11869     for ac_exec_ext in '' $ac_executable_extensions; do
11870       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
11871       as_fn_executable_p "$ac_path_EGREP" || continue
11872 # Check for GNU ac_path_EGREP and select it if it is found.
11873   # Check for GNU $ac_path_EGREP
11874 case `"$ac_path_EGREP" --version 2>&1` in
11875 *GNU*)
11876   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
11877 *)
11878   ac_count=0
11879   $as_echo_n 0123456789 >"conftest.in"
11880   while :
11881   do
11882     cat "conftest.in" "conftest.in" >"conftest.tmp"
11883     mv "conftest.tmp" "conftest.in"
11884     cp "conftest.in" "conftest.nl"
11885     $as_echo 'EGREP' >> "conftest.nl"
11886     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
11887     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
11888     as_fn_arith $ac_count + 1 && ac_count=$as_val
11889     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
11890       # Best one so far, save it but keep looking for a better one
11891       ac_cv_path_EGREP="$ac_path_EGREP"
11892       ac_path_EGREP_max=$ac_count
11893     fi
11894     # 10*(2^10) chars as input seems more than enough
11895     test $ac_count -gt 10 && break
11896   done
11897   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
11898 esac
11899 
11900       $ac_path_EGREP_found && break 3
11901     done
11902   done
11903   done
11904 IFS=$as_save_IFS
11905   if test -z "$ac_cv_path_EGREP"; then
11906     as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
11907   fi
11908 else
11909   ac_cv_path_EGREP=$EGREP
11910 fi
11911 
11912    fi
11913 fi
11914 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
11915 $as_echo "$ac_cv_path_EGREP" >&6; }
11916  EGREP="$ac_cv_path_EGREP"
11917 
11918 
11919     else
11920       # If it succeeded, then it was overridden by the user. We will use it
11921       # for the tool.
11922 
11923       # First remove it from the list of overridden variables, so we can test
11924       # for unknown variables in the end.
11925       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
11926 
11927       # Check if the provided tool contains a complete path.
11928       tool_specified="$EGREP"
11929       tool_basename="${tool_specified##*/}"
11930       if test "x$tool_basename" = "x$tool_specified"; then
11931         # A command without a complete path is provided, search $PATH.
11932         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
11933 $as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
11934         # Extract the first word of "$tool_basename", so it can be a program name with args.
11935 set dummy $tool_basename; ac_word=$2
11936 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11937 $as_echo_n "checking for $ac_word... " >&6; }
11938 if ${ac_cv_path_EGREP+:} false; then :
11939   $as_echo_n "(cached) " >&6
11940 else
11941   case $EGREP in
11942   [\\/]* | ?:[\\/]*)
11943   ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
11944   ;;
11945   *)
11946   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11947 for as_dir in $PATH
11948 do
11949   IFS=$as_save_IFS
11950   test -z "$as_dir" && as_dir=.
11951     for ac_exec_ext in '' $ac_executable_extensions; do
11952   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11953     ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
11954     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11955     break 2
11956   fi
11957 done
11958   done
11959 IFS=$as_save_IFS
11960 
11961   ;;
11962 esac
11963 fi
11964 EGREP=$ac_cv_path_EGREP
11965 if test -n "$EGREP"; then
11966   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
11967 $as_echo "$EGREP" >&6; }
11968 else
11969   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11970 $as_echo "no" >&6; }
11971 fi
11972 
11973 
11974         if test "x$EGREP" = x; then
11975           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
11976         fi
11977       else
11978         # Otherwise we believe it is a complete path. Use it as it is.
11979         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
11980 $as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
11981         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
11982 $as_echo_n "checking for EGREP... " >&6; }
11983         if test ! -x "$tool_specified"; then
11984           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
11985 $as_echo "not found" >&6; }
11986           as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
11987         fi
11988         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
11989 $as_echo "$tool_specified" >&6; }
11990       fi
11991     fi
11992   fi
11993 
11994 
11995   if test "x$EGREP" = x; then
11996     as_fn_error $? "Could not find required tool for EGREP" "$LINENO" 5
11997   fi
11998 
11999 
12000 
12001 
12002   # Publish this variable in the help.
12003 
12004 
12005   if test "x$FGREP" = x; then
12006     # The variable is not set by user, try to locate tool using the code snippet
12007     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12008 $as_echo_n "checking for fgrep... " >&6; }
12009 if ${ac_cv_path_FGREP+:} false; then :
12010   $as_echo_n "(cached) " >&6
12011 else
12012   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12013    then ac_cv_path_FGREP="$GREP -F"
12014    else
12015      if test -z "$FGREP"; then
12016   ac_path_FGREP_found=false
12017   # Loop through the user's path and test for each of PROGNAME-LIST
12018   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12019 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12020 do
12021   IFS=$as_save_IFS
12022   test -z "$as_dir" && as_dir=.
12023     for ac_prog in fgrep; do
12024     for ac_exec_ext in '' $ac_executable_extensions; do
12025       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12026       as_fn_executable_p "$ac_path_FGREP" || continue
12027 # Check for GNU ac_path_FGREP and select it if it is found.
12028   # Check for GNU $ac_path_FGREP
12029 case `"$ac_path_FGREP" --version 2>&1` in
12030 *GNU*)
12031   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12032 *)
12033   ac_count=0
12034   $as_echo_n 0123456789 >"conftest.in"
12035   while :
12036   do
12037     cat "conftest.in" "conftest.in" >"conftest.tmp"
12038     mv "conftest.tmp" "conftest.in"
12039     cp "conftest.in" "conftest.nl"
12040     $as_echo 'FGREP' >> "conftest.nl"
12041     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12042     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12043     as_fn_arith $ac_count + 1 && ac_count=$as_val
12044     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12045       # Best one so far, save it but keep looking for a better one
12046       ac_cv_path_FGREP="$ac_path_FGREP"
12047       ac_path_FGREP_max=$ac_count
12048     fi
12049     # 10*(2^10) chars as input seems more than enough
12050     test $ac_count -gt 10 && break
12051   done
12052   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12053 esac
12054 
12055       $ac_path_FGREP_found && break 3
12056     done
12057   done
12058   done
12059 IFS=$as_save_IFS
12060   if test -z "$ac_cv_path_FGREP"; then
12061     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12062   fi
12063 else
12064   ac_cv_path_FGREP=$FGREP
12065 fi
12066 
12067    fi
12068 fi
12069 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12070 $as_echo "$ac_cv_path_FGREP" >&6; }
12071  FGREP="$ac_cv_path_FGREP"
12072 
12073 
12074   else
12075     # The variable is set, but is it from the command line or the environment?
12076 
12077     # Try to remove the string !FGREP! from our list.
12078     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!FGREP!/}
12079     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12080       # If it failed, the variable was not from the command line. Ignore it,
12081       # but warn the user (except for BASH, which is always set by the calling BASH).
12082       if test "xFGREP" != xBASH; then
12083         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
12084 $as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
12085       fi
12086       # Try to locate tool using the code snippet
12087       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
12088 $as_echo_n "checking for fgrep... " >&6; }
12089 if ${ac_cv_path_FGREP+:} false; then :
12090   $as_echo_n "(cached) " >&6
12091 else
12092   if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
12093    then ac_cv_path_FGREP="$GREP -F"
12094    else
12095      if test -z "$FGREP"; then
12096   ac_path_FGREP_found=false
12097   # Loop through the user's path and test for each of PROGNAME-LIST
12098   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12099 for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
12100 do
12101   IFS=$as_save_IFS
12102   test -z "$as_dir" && as_dir=.
12103     for ac_prog in fgrep; do
12104     for ac_exec_ext in '' $ac_executable_extensions; do
12105       ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
12106       as_fn_executable_p "$ac_path_FGREP" || continue
12107 # Check for GNU ac_path_FGREP and select it if it is found.
12108   # Check for GNU $ac_path_FGREP
12109 case `"$ac_path_FGREP" --version 2>&1` in
12110 *GNU*)
12111   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
12112 *)
12113   ac_count=0
12114   $as_echo_n 0123456789 >"conftest.in"
12115   while :
12116   do
12117     cat "conftest.in" "conftest.in" >"conftest.tmp"
12118     mv "conftest.tmp" "conftest.in"
12119     cp "conftest.in" "conftest.nl"
12120     $as_echo 'FGREP' >> "conftest.nl"
12121     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
12122     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12123     as_fn_arith $ac_count + 1 && ac_count=$as_val
12124     if test $ac_count -gt ${ac_path_FGREP_max-0}; then
12125       # Best one so far, save it but keep looking for a better one
12126       ac_cv_path_FGREP="$ac_path_FGREP"
12127       ac_path_FGREP_max=$ac_count
12128     fi
12129     # 10*(2^10) chars as input seems more than enough
12130     test $ac_count -gt 10 && break
12131   done
12132   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12133 esac
12134 
12135       $ac_path_FGREP_found && break 3
12136     done
12137   done
12138   done
12139 IFS=$as_save_IFS
12140   if test -z "$ac_cv_path_FGREP"; then
12141     as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
12142   fi
12143 else
12144   ac_cv_path_FGREP=$FGREP
12145 fi
12146 
12147    fi
12148 fi
12149 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
12150 $as_echo "$ac_cv_path_FGREP" >&6; }
12151  FGREP="$ac_cv_path_FGREP"
12152 
12153 
12154     else
12155       # If it succeeded, then it was overridden by the user. We will use it
12156       # for the tool.
12157 
12158       # First remove it from the list of overridden variables, so we can test
12159       # for unknown variables in the end.
12160       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12161 
12162       # Check if the provided tool contains a complete path.
12163       tool_specified="$FGREP"
12164       tool_basename="${tool_specified##*/}"
12165       if test "x$tool_basename" = "x$tool_specified"; then
12166         # A command without a complete path is provided, search $PATH.
12167         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
12168 $as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
12169         # Extract the first word of "$tool_basename", so it can be a program name with args.
12170 set dummy $tool_basename; ac_word=$2
12171 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12172 $as_echo_n "checking for $ac_word... " >&6; }
12173 if ${ac_cv_path_FGREP+:} false; then :
12174   $as_echo_n "(cached) " >&6
12175 else
12176   case $FGREP in
12177   [\\/]* | ?:[\\/]*)
12178   ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
12179   ;;
12180   *)
12181   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12182 for as_dir in $PATH
12183 do
12184   IFS=$as_save_IFS
12185   test -z "$as_dir" && as_dir=.
12186     for ac_exec_ext in '' $ac_executable_extensions; do
12187   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12188     ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
12189     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12190     break 2
12191   fi
12192 done
12193   done
12194 IFS=$as_save_IFS
12195 
12196   ;;
12197 esac
12198 fi
12199 FGREP=$ac_cv_path_FGREP
12200 if test -n "$FGREP"; then
12201   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
12202 $as_echo "$FGREP" >&6; }
12203 else
12204   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12205 $as_echo "no" >&6; }
12206 fi
12207 
12208 
12209         if test "x$FGREP" = x; then
12210           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12211         fi
12212       else
12213         # Otherwise we believe it is a complete path. Use it as it is.
12214         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
12215 $as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
12216         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
12217 $as_echo_n "checking for FGREP... " >&6; }
12218         if test ! -x "$tool_specified"; then
12219           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12220 $as_echo "not found" >&6; }
12221           as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
12222         fi
12223         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12224 $as_echo "$tool_specified" >&6; }
12225       fi
12226     fi
12227   fi
12228 
12229 
12230   if test "x$FGREP" = x; then
12231     as_fn_error $? "Could not find required tool for FGREP" "$LINENO" 5
12232   fi
12233 
12234 
12235 
12236 
12237   # Publish this variable in the help.
12238 
12239 
12240   if test "x$SED" = x; then
12241     # The variable is not set by user, try to locate tool using the code snippet
12242     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12243 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12244 if ${ac_cv_path_SED+:} false; then :
12245   $as_echo_n "(cached) " >&6
12246 else
12247             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12248      for ac_i in 1 2 3 4 5 6 7; do
12249        ac_script="$ac_script$as_nl$ac_script"
12250      done
12251      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12252      { ac_script=; unset ac_script;}
12253      if test -z "$SED"; then
12254   ac_path_SED_found=false
12255   # Loop through the user's path and test for each of PROGNAME-LIST
12256   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12257 for as_dir in $PATH
12258 do
12259   IFS=$as_save_IFS
12260   test -z "$as_dir" && as_dir=.
12261     for ac_prog in sed gsed; do
12262     for ac_exec_ext in '' $ac_executable_extensions; do
12263       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12264       as_fn_executable_p "$ac_path_SED" || continue
12265 # Check for GNU ac_path_SED and select it if it is found.
12266   # Check for GNU $ac_path_SED
12267 case `"$ac_path_SED" --version 2>&1` in
12268 *GNU*)
12269   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12270 *)
12271   ac_count=0
12272   $as_echo_n 0123456789 >"conftest.in"
12273   while :
12274   do
12275     cat "conftest.in" "conftest.in" >"conftest.tmp"
12276     mv "conftest.tmp" "conftest.in"
12277     cp "conftest.in" "conftest.nl"
12278     $as_echo '' >> "conftest.nl"
12279     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12280     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12281     as_fn_arith $ac_count + 1 && ac_count=$as_val
12282     if test $ac_count -gt ${ac_path_SED_max-0}; then
12283       # Best one so far, save it but keep looking for a better one
12284       ac_cv_path_SED="$ac_path_SED"
12285       ac_path_SED_max=$ac_count
12286     fi
12287     # 10*(2^10) chars as input seems more than enough
12288     test $ac_count -gt 10 && break
12289   done
12290   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12291 esac
12292 
12293       $ac_path_SED_found && break 3
12294     done
12295   done
12296   done
12297 IFS=$as_save_IFS
12298   if test -z "$ac_cv_path_SED"; then
12299     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12300   fi
12301 else
12302   ac_cv_path_SED=$SED
12303 fi
12304 
12305 fi
12306 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12307 $as_echo "$ac_cv_path_SED" >&6; }
12308  SED="$ac_cv_path_SED"
12309   rm -f conftest.sed
12310 
12311   else
12312     # The variable is set, but is it from the command line or the environment?
12313 
12314     # Try to remove the string !SED! from our list.
12315     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SED!/}
12316     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12317       # If it failed, the variable was not from the command line. Ignore it,
12318       # but warn the user (except for BASH, which is always set by the calling BASH).
12319       if test "xSED" != xBASH; then
12320         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
12321 $as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
12322       fi
12323       # Try to locate tool using the code snippet
12324       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
12325 $as_echo_n "checking for a sed that does not truncate output... " >&6; }
12326 if ${ac_cv_path_SED+:} false; then :
12327   $as_echo_n "(cached) " >&6
12328 else
12329             ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
12330      for ac_i in 1 2 3 4 5 6 7; do
12331        ac_script="$ac_script$as_nl$ac_script"
12332      done
12333      echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
12334      { ac_script=; unset ac_script;}
12335      if test -z "$SED"; then
12336   ac_path_SED_found=false
12337   # Loop through the user's path and test for each of PROGNAME-LIST
12338   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12339 for as_dir in $PATH
12340 do
12341   IFS=$as_save_IFS
12342   test -z "$as_dir" && as_dir=.
12343     for ac_prog in sed gsed; do
12344     for ac_exec_ext in '' $ac_executable_extensions; do
12345       ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
12346       as_fn_executable_p "$ac_path_SED" || continue
12347 # Check for GNU ac_path_SED and select it if it is found.
12348   # Check for GNU $ac_path_SED
12349 case `"$ac_path_SED" --version 2>&1` in
12350 *GNU*)
12351   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
12352 *)
12353   ac_count=0
12354   $as_echo_n 0123456789 >"conftest.in"
12355   while :
12356   do
12357     cat "conftest.in" "conftest.in" >"conftest.tmp"
12358     mv "conftest.tmp" "conftest.in"
12359     cp "conftest.in" "conftest.nl"
12360     $as_echo '' >> "conftest.nl"
12361     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
12362     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
12363     as_fn_arith $ac_count + 1 && ac_count=$as_val
12364     if test $ac_count -gt ${ac_path_SED_max-0}; then
12365       # Best one so far, save it but keep looking for a better one
12366       ac_cv_path_SED="$ac_path_SED"
12367       ac_path_SED_max=$ac_count
12368     fi
12369     # 10*(2^10) chars as input seems more than enough
12370     test $ac_count -gt 10 && break
12371   done
12372   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
12373 esac
12374 
12375       $ac_path_SED_found && break 3
12376     done
12377   done
12378   done
12379 IFS=$as_save_IFS
12380   if test -z "$ac_cv_path_SED"; then
12381     as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
12382   fi
12383 else
12384   ac_cv_path_SED=$SED
12385 fi
12386 
12387 fi
12388 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
12389 $as_echo "$ac_cv_path_SED" >&6; }
12390  SED="$ac_cv_path_SED"
12391   rm -f conftest.sed
12392 
12393     else
12394       # If it succeeded, then it was overridden by the user. We will use it
12395       # for the tool.
12396 
12397       # First remove it from the list of overridden variables, so we can test
12398       # for unknown variables in the end.
12399       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12400 
12401       # Check if the provided tool contains a complete path.
12402       tool_specified="$SED"
12403       tool_basename="${tool_specified##*/}"
12404       if test "x$tool_basename" = "x$tool_specified"; then
12405         # A command without a complete path is provided, search $PATH.
12406         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
12407 $as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
12408         # Extract the first word of "$tool_basename", so it can be a program name with args.
12409 set dummy $tool_basename; ac_word=$2
12410 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12411 $as_echo_n "checking for $ac_word... " >&6; }
12412 if ${ac_cv_path_SED+:} false; then :
12413   $as_echo_n "(cached) " >&6
12414 else
12415   case $SED in
12416   [\\/]* | ?:[\\/]*)
12417   ac_cv_path_SED="$SED" # Let the user override the test with a path.
12418   ;;
12419   *)
12420   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12421 for as_dir in $PATH
12422 do
12423   IFS=$as_save_IFS
12424   test -z "$as_dir" && as_dir=.
12425     for ac_exec_ext in '' $ac_executable_extensions; do
12426   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12427     ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
12428     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12429     break 2
12430   fi
12431 done
12432   done
12433 IFS=$as_save_IFS
12434 
12435   ;;
12436 esac
12437 fi
12438 SED=$ac_cv_path_SED
12439 if test -n "$SED"; then
12440   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
12441 $as_echo "$SED" >&6; }
12442 else
12443   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12444 $as_echo "no" >&6; }
12445 fi
12446 
12447 
12448         if test "x$SED" = x; then
12449           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12450         fi
12451       else
12452         # Otherwise we believe it is a complete path. Use it as it is.
12453         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
12454 $as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
12455         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
12456 $as_echo_n "checking for SED... " >&6; }
12457         if test ! -x "$tool_specified"; then
12458           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12459 $as_echo "not found" >&6; }
12460           as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
12461         fi
12462         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12463 $as_echo "$tool_specified" >&6; }
12464       fi
12465     fi
12466   fi
12467 
12468 
12469   if test "x$SED" = x; then
12470     as_fn_error $? "Could not find required tool for SED" "$LINENO" 5
12471   fi
12472 
12473 
12474 
12475   # Always force rm.
12476   RM="$RM -f"
12477 
12478   # pwd behaves differently on various platforms and some don't support the -L flag.
12479   # Always use the bash builtin pwd to get uniform behavior.
12480   THEPWDCMD=pwd
12481 
12482   # These are not required on all platforms
12483 
12484 
12485   # Publish this variable in the help.
12486 
12487 
12488   if test "x$CYGPATH" = x; then
12489     # The variable is not set by user, try to locate tool using the code snippet
12490     for ac_prog in cygpath
12491 do
12492   # Extract the first word of "$ac_prog", so it can be a program name with args.
12493 set dummy $ac_prog; ac_word=$2
12494 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12495 $as_echo_n "checking for $ac_word... " >&6; }
12496 if ${ac_cv_path_CYGPATH+:} false; then :
12497   $as_echo_n "(cached) " >&6
12498 else
12499   case $CYGPATH in
12500   [\\/]* | ?:[\\/]*)
12501   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12502   ;;
12503   *)
12504   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12505 for as_dir in $PATH
12506 do
12507   IFS=$as_save_IFS
12508   test -z "$as_dir" && as_dir=.
12509     for ac_exec_ext in '' $ac_executable_extensions; do
12510   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12511     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12512     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12513     break 2
12514   fi
12515 done
12516   done
12517 IFS=$as_save_IFS
12518 
12519   ;;
12520 esac
12521 fi
12522 CYGPATH=$ac_cv_path_CYGPATH
12523 if test -n "$CYGPATH"; then
12524   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12525 $as_echo "$CYGPATH" >&6; }
12526 else
12527   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12528 $as_echo "no" >&6; }
12529 fi
12530 
12531 
12532   test -n "$CYGPATH" && break
12533 done
12534 
12535   else
12536     # The variable is set, but is it from the command line or the environment?
12537 
12538     # Try to remove the string !CYGPATH! from our list.
12539     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CYGPATH!/}
12540     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12541       # If it failed, the variable was not from the command line. Ignore it,
12542       # but warn the user (except for BASH, which is always set by the calling BASH).
12543       if test "xCYGPATH" != xBASH; then
12544         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
12545 $as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
12546       fi
12547       # Try to locate tool using the code snippet
12548       for ac_prog in cygpath
12549 do
12550   # Extract the first word of "$ac_prog", so it can be a program name with args.
12551 set dummy $ac_prog; ac_word=$2
12552 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12553 $as_echo_n "checking for $ac_word... " >&6; }
12554 if ${ac_cv_path_CYGPATH+:} false; then :
12555   $as_echo_n "(cached) " >&6
12556 else
12557   case $CYGPATH in
12558   [\\/]* | ?:[\\/]*)
12559   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12560   ;;
12561   *)
12562   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12563 for as_dir in $PATH
12564 do
12565   IFS=$as_save_IFS
12566   test -z "$as_dir" && as_dir=.
12567     for ac_exec_ext in '' $ac_executable_extensions; do
12568   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12569     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12570     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12571     break 2
12572   fi
12573 done
12574   done
12575 IFS=$as_save_IFS
12576 
12577   ;;
12578 esac
12579 fi
12580 CYGPATH=$ac_cv_path_CYGPATH
12581 if test -n "$CYGPATH"; then
12582   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12583 $as_echo "$CYGPATH" >&6; }
12584 else
12585   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12586 $as_echo "no" >&6; }
12587 fi
12588 
12589 
12590   test -n "$CYGPATH" && break
12591 done
12592 
12593     else
12594       # If it succeeded, then it was overridden by the user. We will use it
12595       # for the tool.
12596 
12597       # First remove it from the list of overridden variables, so we can test
12598       # for unknown variables in the end.
12599       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12600 
12601       # Check if the provided tool contains a complete path.
12602       tool_specified="$CYGPATH"
12603       tool_basename="${tool_specified##*/}"
12604       if test "x$tool_basename" = "x$tool_specified"; then
12605         # A command without a complete path is provided, search $PATH.
12606         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
12607 $as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
12608         # Extract the first word of "$tool_basename", so it can be a program name with args.
12609 set dummy $tool_basename; ac_word=$2
12610 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12611 $as_echo_n "checking for $ac_word... " >&6; }
12612 if ${ac_cv_path_CYGPATH+:} false; then :
12613   $as_echo_n "(cached) " >&6
12614 else
12615   case $CYGPATH in
12616   [\\/]* | ?:[\\/]*)
12617   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
12618   ;;
12619   *)
12620   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12621 for as_dir in $PATH
12622 do
12623   IFS=$as_save_IFS
12624   test -z "$as_dir" && as_dir=.
12625     for ac_exec_ext in '' $ac_executable_extensions; do
12626   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12627     ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
12628     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12629     break 2
12630   fi
12631 done
12632   done
12633 IFS=$as_save_IFS
12634 
12635   ;;
12636 esac
12637 fi
12638 CYGPATH=$ac_cv_path_CYGPATH
12639 if test -n "$CYGPATH"; then
12640   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
12641 $as_echo "$CYGPATH" >&6; }
12642 else
12643   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12644 $as_echo "no" >&6; }
12645 fi
12646 
12647 
12648         if test "x$CYGPATH" = x; then
12649           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12650         fi
12651       else
12652         # Otherwise we believe it is a complete path. Use it as it is.
12653         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
12654 $as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
12655         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
12656 $as_echo_n "checking for CYGPATH... " >&6; }
12657         if test ! -x "$tool_specified"; then
12658           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12659 $as_echo "not found" >&6; }
12660           as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
12661         fi
12662         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12663 $as_echo "$tool_specified" >&6; }
12664       fi
12665     fi
12666   fi
12667 
12668 
12669 
12670 
12671   # Publish this variable in the help.
12672 
12673 
12674   if test "x$READLINK" = x; then
12675     # The variable is not set by user, try to locate tool using the code snippet
12676     for ac_prog in greadlink readlink
12677 do
12678   # Extract the first word of "$ac_prog", so it can be a program name with args.
12679 set dummy $ac_prog; ac_word=$2
12680 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12681 $as_echo_n "checking for $ac_word... " >&6; }
12682 if ${ac_cv_path_READLINK+:} false; then :
12683   $as_echo_n "(cached) " >&6
12684 else
12685   case $READLINK in
12686   [\\/]* | ?:[\\/]*)
12687   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12688   ;;
12689   *)
12690   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12691 for as_dir in $PATH
12692 do
12693   IFS=$as_save_IFS
12694   test -z "$as_dir" && as_dir=.
12695     for ac_exec_ext in '' $ac_executable_extensions; do
12696   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12697     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12698     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12699     break 2
12700   fi
12701 done
12702   done
12703 IFS=$as_save_IFS
12704 
12705   ;;
12706 esac
12707 fi
12708 READLINK=$ac_cv_path_READLINK
12709 if test -n "$READLINK"; then
12710   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12711 $as_echo "$READLINK" >&6; }
12712 else
12713   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12714 $as_echo "no" >&6; }
12715 fi
12716 
12717 
12718   test -n "$READLINK" && break
12719 done
12720 
12721   else
12722     # The variable is set, but is it from the command line or the environment?
12723 
12724     # Try to remove the string !READLINK! from our list.
12725     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READLINK!/}
12726     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12727       # If it failed, the variable was not from the command line. Ignore it,
12728       # but warn the user (except for BASH, which is always set by the calling BASH).
12729       if test "xREADLINK" != xBASH; then
12730         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
12731 $as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
12732       fi
12733       # Try to locate tool using the code snippet
12734       for ac_prog in greadlink readlink
12735 do
12736   # Extract the first word of "$ac_prog", so it can be a program name with args.
12737 set dummy $ac_prog; ac_word=$2
12738 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12739 $as_echo_n "checking for $ac_word... " >&6; }
12740 if ${ac_cv_path_READLINK+:} false; then :
12741   $as_echo_n "(cached) " >&6
12742 else
12743   case $READLINK in
12744   [\\/]* | ?:[\\/]*)
12745   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12746   ;;
12747   *)
12748   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12749 for as_dir in $PATH
12750 do
12751   IFS=$as_save_IFS
12752   test -z "$as_dir" && as_dir=.
12753     for ac_exec_ext in '' $ac_executable_extensions; do
12754   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12755     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12756     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12757     break 2
12758   fi
12759 done
12760   done
12761 IFS=$as_save_IFS
12762 
12763   ;;
12764 esac
12765 fi
12766 READLINK=$ac_cv_path_READLINK
12767 if test -n "$READLINK"; then
12768   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12769 $as_echo "$READLINK" >&6; }
12770 else
12771   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12772 $as_echo "no" >&6; }
12773 fi
12774 
12775 
12776   test -n "$READLINK" && break
12777 done
12778 
12779     else
12780       # If it succeeded, then it was overridden by the user. We will use it
12781       # for the tool.
12782 
12783       # First remove it from the list of overridden variables, so we can test
12784       # for unknown variables in the end.
12785       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12786 
12787       # Check if the provided tool contains a complete path.
12788       tool_specified="$READLINK"
12789       tool_basename="${tool_specified##*/}"
12790       if test "x$tool_basename" = "x$tool_specified"; then
12791         # A command without a complete path is provided, search $PATH.
12792         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
12793 $as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
12794         # Extract the first word of "$tool_basename", so it can be a program name with args.
12795 set dummy $tool_basename; ac_word=$2
12796 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12797 $as_echo_n "checking for $ac_word... " >&6; }
12798 if ${ac_cv_path_READLINK+:} false; then :
12799   $as_echo_n "(cached) " >&6
12800 else
12801   case $READLINK in
12802   [\\/]* | ?:[\\/]*)
12803   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
12804   ;;
12805   *)
12806   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12807 for as_dir in $PATH
12808 do
12809   IFS=$as_save_IFS
12810   test -z "$as_dir" && as_dir=.
12811     for ac_exec_ext in '' $ac_executable_extensions; do
12812   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12813     ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
12814     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12815     break 2
12816   fi
12817 done
12818   done
12819 IFS=$as_save_IFS
12820 
12821   ;;
12822 esac
12823 fi
12824 READLINK=$ac_cv_path_READLINK
12825 if test -n "$READLINK"; then
12826   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
12827 $as_echo "$READLINK" >&6; }
12828 else
12829   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12830 $as_echo "no" >&6; }
12831 fi
12832 
12833 
12834         if test "x$READLINK" = x; then
12835           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
12836         fi
12837       else
12838         # Otherwise we believe it is a complete path. Use it as it is.
12839         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
12840 $as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
12841         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
12842 $as_echo_n "checking for READLINK... " >&6; }
12843         if test ! -x "$tool_specified"; then
12844           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
12845 $as_echo "not found" >&6; }
12846           as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
12847         fi
12848         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
12849 $as_echo "$tool_specified" >&6; }
12850       fi
12851     fi
12852   fi
12853 
12854 
12855 
12856 
12857   # Publish this variable in the help.
12858 
12859 
12860   if test "x$DF" = x; then
12861     # The variable is not set by user, try to locate tool using the code snippet
12862     for ac_prog in df
12863 do
12864   # Extract the first word of "$ac_prog", so it can be a program name with args.
12865 set dummy $ac_prog; ac_word=$2
12866 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12867 $as_echo_n "checking for $ac_word... " >&6; }
12868 if ${ac_cv_path_DF+:} false; then :
12869   $as_echo_n "(cached) " >&6
12870 else
12871   case $DF in
12872   [\\/]* | ?:[\\/]*)
12873   ac_cv_path_DF="$DF" # Let the user override the test with a path.
12874   ;;
12875   *)
12876   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12877 for as_dir in $PATH
12878 do
12879   IFS=$as_save_IFS
12880   test -z "$as_dir" && as_dir=.
12881     for ac_exec_ext in '' $ac_executable_extensions; do
12882   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12883     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12884     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12885     break 2
12886   fi
12887 done
12888   done
12889 IFS=$as_save_IFS
12890 
12891   ;;
12892 esac
12893 fi
12894 DF=$ac_cv_path_DF
12895 if test -n "$DF"; then
12896   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12897 $as_echo "$DF" >&6; }
12898 else
12899   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12900 $as_echo "no" >&6; }
12901 fi
12902 
12903 
12904   test -n "$DF" && break
12905 done
12906 
12907   else
12908     # The variable is set, but is it from the command line or the environment?
12909 
12910     # Try to remove the string !DF! from our list.
12911     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DF!/}
12912     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
12913       # If it failed, the variable was not from the command line. Ignore it,
12914       # but warn the user (except for BASH, which is always set by the calling BASH).
12915       if test "xDF" != xBASH; then
12916         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
12917 $as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
12918       fi
12919       # Try to locate tool using the code snippet
12920       for ac_prog in df
12921 do
12922   # Extract the first word of "$ac_prog", so it can be a program name with args.
12923 set dummy $ac_prog; ac_word=$2
12924 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12925 $as_echo_n "checking for $ac_word... " >&6; }
12926 if ${ac_cv_path_DF+:} false; then :
12927   $as_echo_n "(cached) " >&6
12928 else
12929   case $DF in
12930   [\\/]* | ?:[\\/]*)
12931   ac_cv_path_DF="$DF" # Let the user override the test with a path.
12932   ;;
12933   *)
12934   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12935 for as_dir in $PATH
12936 do
12937   IFS=$as_save_IFS
12938   test -z "$as_dir" && as_dir=.
12939     for ac_exec_ext in '' $ac_executable_extensions; do
12940   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12941     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
12942     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12943     break 2
12944   fi
12945 done
12946   done
12947 IFS=$as_save_IFS
12948 
12949   ;;
12950 esac
12951 fi
12952 DF=$ac_cv_path_DF
12953 if test -n "$DF"; then
12954   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
12955 $as_echo "$DF" >&6; }
12956 else
12957   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12958 $as_echo "no" >&6; }
12959 fi
12960 
12961 
12962   test -n "$DF" && break
12963 done
12964 
12965     else
12966       # If it succeeded, then it was overridden by the user. We will use it
12967       # for the tool.
12968 
12969       # First remove it from the list of overridden variables, so we can test
12970       # for unknown variables in the end.
12971       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
12972 
12973       # Check if the provided tool contains a complete path.
12974       tool_specified="$DF"
12975       tool_basename="${tool_specified##*/}"
12976       if test "x$tool_basename" = "x$tool_specified"; then
12977         # A command without a complete path is provided, search $PATH.
12978         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
12979 $as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
12980         # Extract the first word of "$tool_basename", so it can be a program name with args.
12981 set dummy $tool_basename; ac_word=$2
12982 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12983 $as_echo_n "checking for $ac_word... " >&6; }
12984 if ${ac_cv_path_DF+:} false; then :
12985   $as_echo_n "(cached) " >&6
12986 else
12987   case $DF in
12988   [\\/]* | ?:[\\/]*)
12989   ac_cv_path_DF="$DF" # Let the user override the test with a path.
12990   ;;
12991   *)
12992   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12993 for as_dir in $PATH
12994 do
12995   IFS=$as_save_IFS
12996   test -z "$as_dir" && as_dir=.
12997     for ac_exec_ext in '' $ac_executable_extensions; do
12998   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12999     ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
13000     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13001     break 2
13002   fi
13003 done
13004   done
13005 IFS=$as_save_IFS
13006 
13007   ;;
13008 esac
13009 fi
13010 DF=$ac_cv_path_DF
13011 if test -n "$DF"; then
13012   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
13013 $as_echo "$DF" >&6; }
13014 else
13015   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13016 $as_echo "no" >&6; }
13017 fi
13018 
13019 
13020         if test "x$DF" = x; then
13021           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13022         fi
13023       else
13024         # Otherwise we believe it is a complete path. Use it as it is.
13025         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
13026 $as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
13027         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
13028 $as_echo_n "checking for DF... " >&6; }
13029         if test ! -x "$tool_specified"; then
13030           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13031 $as_echo "not found" >&6; }
13032           as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
13033         fi
13034         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13035 $as_echo "$tool_specified" >&6; }
13036       fi
13037     fi
13038   fi
13039 
13040 
13041 
13042 
13043   # Publish this variable in the help.
13044 
13045 
13046   if test "x$SETFILE" = x; then
13047     # The variable is not set by user, try to locate tool using the code snippet
13048     for ac_prog in SetFile
13049 do
13050   # Extract the first word of "$ac_prog", so it can be a program name with args.
13051 set dummy $ac_prog; ac_word=$2
13052 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13053 $as_echo_n "checking for $ac_word... " >&6; }
13054 if ${ac_cv_path_SETFILE+:} false; then :
13055   $as_echo_n "(cached) " >&6
13056 else
13057   case $SETFILE in
13058   [\\/]* | ?:[\\/]*)
13059   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13060   ;;
13061   *)
13062   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13063 for as_dir in $PATH
13064 do
13065   IFS=$as_save_IFS
13066   test -z "$as_dir" && as_dir=.
13067     for ac_exec_ext in '' $ac_executable_extensions; do
13068   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13069     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13070     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13071     break 2
13072   fi
13073 done
13074   done
13075 IFS=$as_save_IFS
13076 
13077   ;;
13078 esac
13079 fi
13080 SETFILE=$ac_cv_path_SETFILE
13081 if test -n "$SETFILE"; then
13082   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13083 $as_echo "$SETFILE" >&6; }
13084 else
13085   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13086 $as_echo "no" >&6; }
13087 fi
13088 
13089 
13090   test -n "$SETFILE" && break
13091 done
13092 
13093   else
13094     # The variable is set, but is it from the command line or the environment?
13095 
13096     # Try to remove the string !SETFILE! from our list.
13097     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!SETFILE!/}
13098     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13099       # If it failed, the variable was not from the command line. Ignore it,
13100       # but warn the user (except for BASH, which is always set by the calling BASH).
13101       if test "xSETFILE" != xBASH; then
13102         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
13103 $as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
13104       fi
13105       # Try to locate tool using the code snippet
13106       for ac_prog in SetFile
13107 do
13108   # Extract the first word of "$ac_prog", so it can be a program name with args.
13109 set dummy $ac_prog; ac_word=$2
13110 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13111 $as_echo_n "checking for $ac_word... " >&6; }
13112 if ${ac_cv_path_SETFILE+:} false; then :
13113   $as_echo_n "(cached) " >&6
13114 else
13115   case $SETFILE in
13116   [\\/]* | ?:[\\/]*)
13117   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13118   ;;
13119   *)
13120   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13121 for as_dir in $PATH
13122 do
13123   IFS=$as_save_IFS
13124   test -z "$as_dir" && as_dir=.
13125     for ac_exec_ext in '' $ac_executable_extensions; do
13126   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13127     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13128     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13129     break 2
13130   fi
13131 done
13132   done
13133 IFS=$as_save_IFS
13134 
13135   ;;
13136 esac
13137 fi
13138 SETFILE=$ac_cv_path_SETFILE
13139 if test -n "$SETFILE"; then
13140   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13141 $as_echo "$SETFILE" >&6; }
13142 else
13143   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13144 $as_echo "no" >&6; }
13145 fi
13146 
13147 
13148   test -n "$SETFILE" && break
13149 done
13150 
13151     else
13152       # If it succeeded, then it was overridden by the user. We will use it
13153       # for the tool.
13154 
13155       # First remove it from the list of overridden variables, so we can test
13156       # for unknown variables in the end.
13157       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13158 
13159       # Check if the provided tool contains a complete path.
13160       tool_specified="$SETFILE"
13161       tool_basename="${tool_specified##*/}"
13162       if test "x$tool_basename" = "x$tool_specified"; then
13163         # A command without a complete path is provided, search $PATH.
13164         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
13165 $as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
13166         # Extract the first word of "$tool_basename", so it can be a program name with args.
13167 set dummy $tool_basename; ac_word=$2
13168 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13169 $as_echo_n "checking for $ac_word... " >&6; }
13170 if ${ac_cv_path_SETFILE+:} false; then :
13171   $as_echo_n "(cached) " >&6
13172 else
13173   case $SETFILE in
13174   [\\/]* | ?:[\\/]*)
13175   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
13176   ;;
13177   *)
13178   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13179 for as_dir in $PATH
13180 do
13181   IFS=$as_save_IFS
13182   test -z "$as_dir" && as_dir=.
13183     for ac_exec_ext in '' $ac_executable_extensions; do
13184   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13185     ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
13186     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13187     break 2
13188   fi
13189 done
13190   done
13191 IFS=$as_save_IFS
13192 
13193   ;;
13194 esac
13195 fi
13196 SETFILE=$ac_cv_path_SETFILE
13197 if test -n "$SETFILE"; then
13198   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
13199 $as_echo "$SETFILE" >&6; }
13200 else
13201   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13202 $as_echo "no" >&6; }
13203 fi
13204 
13205 
13206         if test "x$SETFILE" = x; then
13207           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13208         fi
13209       else
13210         # Otherwise we believe it is a complete path. Use it as it is.
13211         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
13212 $as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
13213         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
13214 $as_echo_n "checking for SETFILE... " >&6; }
13215         if test ! -x "$tool_specified"; then
13216           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13217 $as_echo "not found" >&6; }
13218           as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
13219         fi
13220         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13221 $as_echo "$tool_specified" >&6; }
13222       fi
13223     fi
13224   fi
13225 
13226 
13227 
13228 
13229   # Publish this variable in the help.
13230 
13231 
13232   if test "x$CPIO" = x; then
13233     # The variable is not set by user, try to locate tool using the code snippet
13234     for ac_prog in cpio bsdcpio
13235 do
13236   # Extract the first word of "$ac_prog", so it can be a program name with args.
13237 set dummy $ac_prog; ac_word=$2
13238 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13239 $as_echo_n "checking for $ac_word... " >&6; }
13240 if ${ac_cv_path_CPIO+:} false; then :
13241   $as_echo_n "(cached) " >&6
13242 else
13243   case $CPIO in
13244   [\\/]* | ?:[\\/]*)
13245   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13246   ;;
13247   *)
13248   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13249 for as_dir in $PATH
13250 do
13251   IFS=$as_save_IFS
13252   test -z "$as_dir" && as_dir=.
13253     for ac_exec_ext in '' $ac_executable_extensions; do
13254   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13255     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13256     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13257     break 2
13258   fi
13259 done
13260   done
13261 IFS=$as_save_IFS
13262 
13263   ;;
13264 esac
13265 fi
13266 CPIO=$ac_cv_path_CPIO
13267 if test -n "$CPIO"; then
13268   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13269 $as_echo "$CPIO" >&6; }
13270 else
13271   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13272 $as_echo "no" >&6; }
13273 fi
13274 
13275 
13276   test -n "$CPIO" && break
13277 done
13278 
13279   else
13280     # The variable is set, but is it from the command line or the environment?
13281 
13282     # Try to remove the string !CPIO! from our list.
13283     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CPIO!/}
13284     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
13285       # If it failed, the variable was not from the command line. Ignore it,
13286       # but warn the user (except for BASH, which is always set by the calling BASH).
13287       if test "xCPIO" != xBASH; then
13288         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
13289 $as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
13290       fi
13291       # Try to locate tool using the code snippet
13292       for ac_prog in cpio bsdcpio
13293 do
13294   # Extract the first word of "$ac_prog", so it can be a program name with args.
13295 set dummy $ac_prog; ac_word=$2
13296 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13297 $as_echo_n "checking for $ac_word... " >&6; }
13298 if ${ac_cv_path_CPIO+:} false; then :
13299   $as_echo_n "(cached) " >&6
13300 else
13301   case $CPIO in
13302   [\\/]* | ?:[\\/]*)
13303   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13304   ;;
13305   *)
13306   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13307 for as_dir in $PATH
13308 do
13309   IFS=$as_save_IFS
13310   test -z "$as_dir" && as_dir=.
13311     for ac_exec_ext in '' $ac_executable_extensions; do
13312   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13313     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13314     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13315     break 2
13316   fi
13317 done
13318   done
13319 IFS=$as_save_IFS
13320 
13321   ;;
13322 esac
13323 fi
13324 CPIO=$ac_cv_path_CPIO
13325 if test -n "$CPIO"; then
13326   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13327 $as_echo "$CPIO" >&6; }
13328 else
13329   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13330 $as_echo "no" >&6; }
13331 fi
13332 
13333 
13334   test -n "$CPIO" && break
13335 done
13336 
13337     else
13338       # If it succeeded, then it was overridden by the user. We will use it
13339       # for the tool.
13340 
13341       # First remove it from the list of overridden variables, so we can test
13342       # for unknown variables in the end.
13343       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
13344 
13345       # Check if the provided tool contains a complete path.
13346       tool_specified="$CPIO"
13347       tool_basename="${tool_specified##*/}"
13348       if test "x$tool_basename" = "x$tool_specified"; then
13349         # A command without a complete path is provided, search $PATH.
13350         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
13351 $as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
13352         # Extract the first word of "$tool_basename", so it can be a program name with args.
13353 set dummy $tool_basename; ac_word=$2
13354 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13355 $as_echo_n "checking for $ac_word... " >&6; }
13356 if ${ac_cv_path_CPIO+:} false; then :
13357   $as_echo_n "(cached) " >&6
13358 else
13359   case $CPIO in
13360   [\\/]* | ?:[\\/]*)
13361   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
13362   ;;
13363   *)
13364   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13365 for as_dir in $PATH
13366 do
13367   IFS=$as_save_IFS
13368   test -z "$as_dir" && as_dir=.
13369     for ac_exec_ext in '' $ac_executable_extensions; do
13370   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13371     ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
13372     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13373     break 2
13374   fi
13375 done
13376   done
13377 IFS=$as_save_IFS
13378 
13379   ;;
13380 esac
13381 fi
13382 CPIO=$ac_cv_path_CPIO
13383 if test -n "$CPIO"; then
13384   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
13385 $as_echo "$CPIO" >&6; }
13386 else
13387   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13388 $as_echo "no" >&6; }
13389 fi
13390 
13391 
13392         if test "x$CPIO" = x; then
13393           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
13394         fi
13395       else
13396         # Otherwise we believe it is a complete path. Use it as it is.
13397         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
13398 $as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
13399         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
13400 $as_echo_n "checking for CPIO... " >&6; }
13401         if test ! -x "$tool_specified"; then
13402           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
13403 $as_echo "not found" >&6; }
13404           as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
13405         fi
13406         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
13407 $as_echo "$tool_specified" >&6; }
13408       fi
13409     fi
13410   fi
13411 
13412 
13413 
13414 
13415 # Now we can determine OpenJDK build and target platforms. This is required to
13416 # have early on.
13417 # Make sure we can run config.sub.
13418 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
13419   as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
13420 
13421 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
13422 $as_echo_n "checking build system type... " >&6; }
13423 if ${ac_cv_build+:} false; then :
13424   $as_echo_n "(cached) " >&6
13425 else
13426   ac_build_alias=$build_alias
13427 test "x$ac_build_alias" = x &&
13428   ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
13429 test "x$ac_build_alias" = x &&
13430   as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
13431 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
13432   as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
13433 
13434 fi
13435 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
13436 $as_echo "$ac_cv_build" >&6; }
13437 case $ac_cv_build in
13438 *-*-*) ;;
13439 *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
13440 esac
13441 build=$ac_cv_build
13442 ac_save_IFS=$IFS; IFS='-'
13443 set x $ac_cv_build
13444 shift
13445 build_cpu=$1
13446 build_vendor=$2
13447 shift; shift
13448 # Remember, the first character of IFS is used to create $*,
13449 # except with old shells:
13450 build_os=$*
13451 IFS=$ac_save_IFS
13452 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
13453 
13454 
13455 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
13456 $as_echo_n "checking host system type... " >&6; }
13457 if ${ac_cv_host+:} false; then :
13458   $as_echo_n "(cached) " >&6
13459 else
13460   if test "x$host_alias" = x; then
13461   ac_cv_host=$ac_cv_build
13462 else
13463   ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
13464     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
13465 fi
13466 
13467 fi
13468 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
13469 $as_echo "$ac_cv_host" >&6; }
13470 case $ac_cv_host in
13471 *-*-*) ;;
13472 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
13473 esac
13474 host=$ac_cv_host
13475 ac_save_IFS=$IFS; IFS='-'
13476 set x $ac_cv_host
13477 shift
13478 host_cpu=$1
13479 host_vendor=$2
13480 shift; shift
13481 # Remember, the first character of IFS is used to create $*,
13482 # except with old shells:
13483 host_os=$*
13484 IFS=$ac_save_IFS
13485 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
13486 
13487 
13488 { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
13489 $as_echo_n "checking target system type... " >&6; }
13490 if ${ac_cv_target+:} false; then :
13491   $as_echo_n "(cached) " >&6
13492 else
13493   if test "x$target_alias" = x; then
13494   ac_cv_target=$ac_cv_host
13495 else
13496   ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
13497     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
13498 fi
13499 
13500 fi
13501 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
13502 $as_echo "$ac_cv_target" >&6; }
13503 case $ac_cv_target in
13504 *-*-*) ;;
13505 *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
13506 esac
13507 target=$ac_cv_target
13508 ac_save_IFS=$IFS; IFS='-'
13509 set x $ac_cv_target
13510 shift
13511 target_cpu=$1
13512 target_vendor=$2
13513 shift; shift
13514 # Remember, the first character of IFS is used to create $*,
13515 # except with old shells:
13516 target_os=$*
13517 IFS=$ac_save_IFS
13518 case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
13519 
13520 
13521 # The aliases save the names the user supplied, while $host etc.
13522 # will get canonicalized.
13523 test -n "$target_alias" &&
13524   test "$program_prefix$program_suffix$program_transform_name" = \
13525     NONENONEs,x,x, &&
13526   program_prefix=${target_alias}-
13527 
13528   # Figure out the build and target systems. # Note that in autoconf terminology, "build" is obvious, but "target"
13529   # is confusing; it assumes you are cross-compiling a cross-compiler (!)  and "target" is thus the target of the
13530   # product you're building. The target of this build is called "host". Since this is confusing to most people, we
13531   # have not adopted that system, but use "target" as the platform we are building for. In some places though we need
13532   # to use the configure naming style.
13533 
13534 
13535 
13536 
13537 
13538   # Copy the autoconf trip/quadruplet verbatim to OPENJDK_TARGET_AUTOCONF_NAME
13539   # (from the autoconf "host") and OPENJDK_BUILD_AUTOCONF_NAME
13540   # Note that we might later on rewrite e.g. OPENJDK_TARGET_CPU due to reduced build,
13541   # but this will not change the value of OPENJDK_TARGET_AUTOCONF_NAME.
13542   OPENJDK_TARGET_AUTOCONF_NAME="$host"
13543   OPENJDK_BUILD_AUTOCONF_NAME="$build"
13544 
13545 
13546 
13547   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13548 
13549   case "$build_os" in
13550     *linux*)
13551       VAR_OS=linux
13552       VAR_OS_TYPE=unix
13553       ;;
13554     *solaris*)
13555       VAR_OS=solaris
13556       VAR_OS_TYPE=unix
13557       ;;
13558     *darwin*)
13559       VAR_OS=macosx
13560       VAR_OS_TYPE=unix
13561       ;;
13562     *bsd*)
13563       VAR_OS=bsd
13564       VAR_OS_TYPE=unix
13565       ;;
13566     *cygwin*)
13567       VAR_OS=windows
13568       VAR_OS_ENV=windows.cygwin
13569       ;;
13570     *mingw*)
13571       VAR_OS=windows
13572       VAR_OS_ENV=windows.msys
13573       ;;
13574     *aix*)
13575       VAR_OS=aix
13576       VAR_OS_TYPE=unix
13577       ;;
13578     *)
13579       as_fn_error $? "unsupported operating system $build_os" "$LINENO" 5
13580       ;;
13581   esac
13582 
13583 
13584   # First argument is the cpu name from the trip/quad
13585   case "$build_cpu" in
13586     x86_64)
13587       VAR_CPU=x86_64
13588       VAR_CPU_ARCH=x86
13589       VAR_CPU_BITS=64
13590       VAR_CPU_ENDIAN=little
13591       ;;
13592     i?86)
13593       VAR_CPU=x86
13594       VAR_CPU_ARCH=x86
13595       VAR_CPU_BITS=32
13596       VAR_CPU_ENDIAN=little
13597       ;;
13598     arm*)
13599       VAR_CPU=arm
13600       VAR_CPU_ARCH=arm
13601       VAR_CPU_BITS=32
13602       VAR_CPU_ENDIAN=little
13603       ;;
13604     aarch64)
13605       VAR_CPU=aarch64
13606       VAR_CPU_ARCH=aarch64
13607       VAR_CPU_BITS=64
13608       VAR_CPU_ENDIAN=little
13609       ;;
13610     powerpc)
13611       VAR_CPU=ppc
13612       VAR_CPU_ARCH=ppc
13613       VAR_CPU_BITS=32
13614       VAR_CPU_ENDIAN=big
13615       ;;
13616     powerpc64)
13617       VAR_CPU=ppc64
13618       VAR_CPU_ARCH=ppc
13619       VAR_CPU_BITS=64
13620       VAR_CPU_ENDIAN=big
13621       ;;
13622     powerpc64le)
13623       VAR_CPU=ppc64
13624       VAR_CPU_ARCH=ppc
13625       VAR_CPU_BITS=64
13626       VAR_CPU_ENDIAN=little
13627       ;;
13628     s390)
13629       VAR_CPU=s390
13630       VAR_CPU_ARCH=s390
13631       VAR_CPU_BITS=32
13632       VAR_CPU_ENDIAN=big
13633       ;;
13634     s390x)
13635       VAR_CPU=s390x
13636       VAR_CPU_ARCH=s390
13637       VAR_CPU_BITS=64
13638       VAR_CPU_ENDIAN=big
13639       ;;
13640     sparc)
13641       VAR_CPU=sparc
13642       VAR_CPU_ARCH=sparc
13643       VAR_CPU_BITS=32
13644       VAR_CPU_ENDIAN=big
13645       ;;
13646     sparcv9|sparc64)
13647       VAR_CPU=sparcv9
13648       VAR_CPU_ARCH=sparc
13649       VAR_CPU_BITS=64
13650       VAR_CPU_ENDIAN=big
13651       ;;
13652     *)
13653       as_fn_error $? "unsupported cpu $build_cpu" "$LINENO" 5
13654       ;;
13655   esac
13656 
13657   # ..and setup our own variables. (Do this explicitely to facilitate searching)
13658   OPENJDK_BUILD_OS="$VAR_OS"
13659   if test "x$VAR_OS_TYPE" != x; then
13660     OPENJDK_BUILD_OS_TYPE="$VAR_OS_TYPE"
13661   else
13662     OPENJDK_BUILD_OS_TYPE="$VAR_OS"
13663   fi
13664   if test "x$VAR_OS_ENV" != x; then
13665     OPENJDK_BUILD_OS_ENV="$VAR_OS_ENV"
13666   else
13667     OPENJDK_BUILD_OS_ENV="$VAR_OS"
13668   fi
13669   OPENJDK_BUILD_CPU="$VAR_CPU"
13670   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
13671   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
13672   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13673 
13674 
13675 
13676 
13677 
13678 
13679 
13680 
13681   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
13682 $as_echo_n "checking openjdk-build os-cpu... " >&6; }
13683   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
13684 $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
13685 
13686   # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
13687 
13688   case "$host_os" in
13689     *linux*)
13690       VAR_OS=linux
13691       VAR_OS_TYPE=unix
13692       ;;
13693     *solaris*)
13694       VAR_OS=solaris
13695       VAR_OS_TYPE=unix
13696       ;;
13697     *darwin*)
13698       VAR_OS=macosx
13699       VAR_OS_TYPE=unix
13700       ;;
13701     *bsd*)
13702       VAR_OS=bsd
13703       VAR_OS_TYPE=unix
13704       ;;
13705     *cygwin*)
13706       VAR_OS=windows
13707       VAR_OS_ENV=windows.cygwin
13708       ;;
13709     *mingw*)
13710       VAR_OS=windows
13711       VAR_OS_ENV=windows.msys
13712       ;;
13713     *aix*)
13714       VAR_OS=aix
13715       VAR_OS_TYPE=unix
13716       ;;
13717     *)
13718       as_fn_error $? "unsupported operating system $host_os" "$LINENO" 5
13719       ;;
13720   esac
13721 
13722 
13723   # First argument is the cpu name from the trip/quad
13724   case "$host_cpu" in
13725     x86_64)
13726       VAR_CPU=x86_64
13727       VAR_CPU_ARCH=x86
13728       VAR_CPU_BITS=64
13729       VAR_CPU_ENDIAN=little
13730       ;;
13731     i?86)
13732       VAR_CPU=x86
13733       VAR_CPU_ARCH=x86
13734       VAR_CPU_BITS=32
13735       VAR_CPU_ENDIAN=little
13736       ;;
13737     arm*)
13738       VAR_CPU=arm
13739       VAR_CPU_ARCH=arm
13740       VAR_CPU_BITS=32
13741       VAR_CPU_ENDIAN=little
13742       ;;
13743     aarch64)
13744       VAR_CPU=aarch64
13745       VAR_CPU_ARCH=aarch64
13746       VAR_CPU_BITS=64
13747       VAR_CPU_ENDIAN=little
13748       ;;
13749     powerpc)
13750       VAR_CPU=ppc
13751       VAR_CPU_ARCH=ppc
13752       VAR_CPU_BITS=32
13753       VAR_CPU_ENDIAN=big
13754       ;;
13755     powerpc64)
13756       VAR_CPU=ppc64
13757       VAR_CPU_ARCH=ppc
13758       VAR_CPU_BITS=64
13759       VAR_CPU_ENDIAN=big
13760       ;;
13761     powerpc64le)
13762       VAR_CPU=ppc64
13763       VAR_CPU_ARCH=ppc
13764       VAR_CPU_BITS=64
13765       VAR_CPU_ENDIAN=little
13766       ;;
13767     s390)
13768       VAR_CPU=s390
13769       VAR_CPU_ARCH=s390
13770       VAR_CPU_BITS=32
13771       VAR_CPU_ENDIAN=big
13772       ;;
13773     s390x)
13774       VAR_CPU=s390x
13775       VAR_CPU_ARCH=s390
13776       VAR_CPU_BITS=64
13777       VAR_CPU_ENDIAN=big
13778       ;;
13779     sparc)
13780       VAR_CPU=sparc
13781       VAR_CPU_ARCH=sparc
13782       VAR_CPU_BITS=32
13783       VAR_CPU_ENDIAN=big
13784       ;;
13785     sparcv9|sparc64)
13786       VAR_CPU=sparcv9
13787       VAR_CPU_ARCH=sparc
13788       VAR_CPU_BITS=64
13789       VAR_CPU_ENDIAN=big
13790       ;;
13791     *)
13792       as_fn_error $? "unsupported cpu $host_cpu" "$LINENO" 5
13793       ;;
13794   esac
13795 
13796   # ... and setup our own variables. (Do this explicitely to facilitate searching)
13797   OPENJDK_TARGET_OS="$VAR_OS"
13798   if test "x$VAR_OS_TYPE" != x; then
13799     OPENJDK_TARGET_OS_TYPE="$VAR_OS_TYPE"
13800   else
13801     OPENJDK_TARGET_OS_TYPE="$VAR_OS"
13802   fi
13803   if test "x$VAR_OS_ENV" != x; then
13804     OPENJDK_TARGET_OS_ENV="$VAR_OS_ENV"
13805   else
13806     OPENJDK_TARGET_OS_ENV="$VAR_OS"
13807   fi
13808   OPENJDK_TARGET_CPU="$VAR_CPU"
13809   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
13810   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
13811   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
13812 
13813 
13814 
13815 
13816 
13817 
13818 
13819 
13820   { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
13821 $as_echo_n "checking openjdk-target os-cpu... " >&6; }
13822   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
13823 $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
13824 
13825 
13826 
13827 # Check whether --with-target-bits was given.
13828 if test "${with_target_bits+set}" = set; then :
13829   withval=$with_target_bits;
13830 fi
13831 
13832 
13833   # We have three types of compiles:
13834   # native  == normal compilation, target system == build system
13835   # cross   == traditional cross compilation, target system != build system; special toolchain needed
13836   # reduced == using native compilers, but with special flags (e.g. -m32) to produce 32-bit builds on 64-bit machines
13837   #
13838   if test "x$OPENJDK_BUILD_AUTOCONF_NAME" != "x$OPENJDK_TARGET_AUTOCONF_NAME"; then
13839     # We're doing a proper cross-compilation
13840     COMPILE_TYPE="cross"
13841   else
13842     COMPILE_TYPE="native"
13843   fi
13844 
13845   if test "x$with_target_bits" != x; then
13846     if test "x$COMPILE_TYPE" = "xcross"; then
13847       as_fn_error $? "It is not possible to combine --with-target-bits=X and proper cross-compilation. Choose either." "$LINENO" 5
13848     fi
13849 
13850     if test "x$with_target_bits" = x32 && test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13851       # A reduced build is requested
13852       COMPILE_TYPE="reduced"
13853       OPENJDK_TARGET_CPU_BITS=32
13854       if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
13855         OPENJDK_TARGET_CPU=x86
13856       elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
13857         OPENJDK_TARGET_CPU=sparc
13858       else
13859         as_fn_error $? "Reduced build (--with-target-bits=32) is only supported on x86_64 and sparcv9" "$LINENO" 5
13860       fi
13861     elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
13862       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
13863     elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
13864       { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
13865 $as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
13866     else
13867       as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
13868     fi
13869   fi
13870 
13871 
13872   { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
13873 $as_echo_n "checking compilation type... " >&6; }
13874   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
13875 $as_echo "$COMPILE_TYPE" >&6; }
13876 
13877 
13878   if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
13879     REQUIRED_OS_NAME=SunOS
13880     REQUIRED_OS_VERSION=5.10
13881   fi
13882   if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
13883     REQUIRED_OS_NAME=Linux
13884     REQUIRED_OS_VERSION=2.6
13885   fi
13886   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
13887     REQUIRED_OS_NAME=Windows
13888     if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
13889       REQUIRED_OS_VERSION=5.2
13890     else
13891       REQUIRED_OS_VERSION=5.1
13892     fi
13893   fi
13894   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
13895     REQUIRED_OS_NAME=Darwin
13896     REQUIRED_OS_VERSION=11.2
13897   fi
13898 
13899 
13900 
13901 
13902 
13903   # Also store the legacy naming of the cpu.
13904   # Ie i586 and amd64 instead of x86 and x86_64
13905   OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
13906   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13907     OPENJDK_TARGET_CPU_LEGACY="i586"
13908   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13909     # On all platforms except MacOSX replace x86_64 with amd64.
13910     OPENJDK_TARGET_CPU_LEGACY="amd64"
13911   fi
13912 
13913 
13914   # And the second legacy naming of the cpu.
13915   # Ie i386 and amd64 instead of x86 and x86_64.
13916   OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
13917   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13918     OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
13919   elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13920     OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
13921   fi
13922 
13923 
13924   # This is the name of the cpu (but using i386 and amd64 instead of
13925   # x86 and x86_64, respectively), preceeded by a /, to be used when
13926   # locating libraries. On macosx, it's empty, though.
13927   OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
13928   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13929     OPENJDK_TARGET_CPU_LIBDIR=""
13930   fi
13931 
13932 
13933   # OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
13934   # /amd64 or /sparcv9. This string is appended to some library paths, like this:
13935   # /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
13936   OPENJDK_TARGET_CPU_ISADIR=""
13937   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13938     if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13939       OPENJDK_TARGET_CPU_ISADIR="/amd64"
13940     elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
13941       OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
13942     fi
13943   fi
13944 
13945 
13946   # Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
13947   OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
13948   if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
13949     # On linux only, we replace x86 with i386.
13950     OPENJDK_TARGET_CPU_OSARCH="i386"
13951   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13952     # On all platforms except macosx, we replace x86_64 with amd64.
13953     OPENJDK_TARGET_CPU_OSARCH="amd64"
13954   fi
13955 
13956 
13957   OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
13958   if test "x$OPENJDK_TARGET_CPU" = xx86; then
13959     OPENJDK_TARGET_CPU_JLI="i386"
13960   elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
13961     # On all platforms except macosx, we replace x86_64 with amd64.
13962     OPENJDK_TARGET_CPU_JLI="amd64"
13963   fi
13964   # Now setup the -D flags for building libjli.
13965   OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
13966   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
13967     if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
13968       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
13969     elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
13970       OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
13971     fi
13972   fi
13973 
13974 
13975   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
13976       OPENJDK_TARGET_OS_EXPORT_DIR=macosx
13977   else
13978       OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_TYPE}
13979   fi
13980 
13981 
13982   if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
13983     A_LP64="LP64:="
13984     # -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
13985     # unpack200.exe
13986     if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
13987       ADD_LP64="-D_LP64=1"
13988     fi
13989   fi
13990   LP64=$A_LP64
13991 
13992 
13993   if test "x$COMPILE_TYPE" = "xcross"; then
13994     # FIXME: ... or should this include reduced builds..?
13995     DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
13996   else
13997     DEFINE_CROSS_COMPILE_ARCH=""
13998   fi
13999 
14000 
14001   # ZERO_ARCHDEF is used to enable architecture-specific code
14002   case "${OPENJDK_TARGET_CPU}" in
14003     ppc)     ZERO_ARCHDEF=PPC32 ;;
14004     ppc64)   ZERO_ARCHDEF=PPC64 ;;
14005     s390*)   ZERO_ARCHDEF=S390  ;;
14006     sparc*)  ZERO_ARCHDEF=SPARC ;;
14007     x86_64*) ZERO_ARCHDEF=AMD64 ;;
14008     x86)     ZERO_ARCHDEF=IA32  ;;
14009     *)      ZERO_ARCHDEF=$(echo "${OPENJDK_TARGET_CPU_LEGACY_LIB}" | tr a-z A-Z)
14010   esac
14011 
14012 
14013 
14014 
14015 # Continue setting up basic stuff. Most remaining code require fundamental tools.
14016 
14017   # Save the current directory this script was started from
14018   CURDIR="$PWD"
14019 
14020   if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
14021     PATH_SEP=";"
14022 
14023   SRC_ROOT_LENGTH=`$THEPWDCMD -L|$WC -m`
14024   if test $SRC_ROOT_LENGTH -gt 100; then
14025     as_fn_error $? "Your base path is too long. It is $SRC_ROOT_LENGTH characters long, but only 100 is supported" "$LINENO" 5
14026   fi
14027 
14028   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14029     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
14030 $as_echo_n "checking cygwin release... " >&6; }
14031     CYGWIN_VERSION=`$UNAME -r`
14032     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
14033 $as_echo "$CYGWIN_VERSION" >&6; }
14034     WINDOWS_ENV_VENDOR='cygwin'
14035     WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
14036 
14037     CYGWIN_VERSION_OK=`$ECHO $CYGWIN_VERSION | $GREP ^1.7.`
14038     if test "x$CYGWIN_VERSION_OK" = x; then
14039       { $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
14040 $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;}
14041       as_fn_error $? "Cannot continue" "$LINENO" 5
14042     fi
14043     if test "x$CYGPATH" = x; then
14044       as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
14045     fi
14046     { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
14047 $as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
14048     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
14049     cygwin_winpath_root=`cd / ; cmd /c cd | grep ".*"`
14050     # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
14051     CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
14052     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
14053 $as_echo "$CYGWIN_ROOT_PATH" >&6; }
14054     WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
14055     test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
14056     if test "x$test_cygdrive_prefix" = x; then
14057       as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
14058     fi
14059   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14060     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
14061 $as_echo_n "checking msys release... " >&6; }
14062     MSYS_VERSION=`$UNAME -r`
14063     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
14064 $as_echo "$MSYS_VERSION" >&6; }
14065 
14066     WINDOWS_ENV_VENDOR='msys'
14067     WINDOWS_ENV_VERSION="$MSYS_VERSION"
14068 
14069     { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
14070 $as_echo_n "checking msys root directory as unix-style path... " >&6; }
14071     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
14072     MSYS_ROOT_PATH=`cd / ; cmd /c cd | grep ".*"`
14073 
14074   windows_path="$MSYS_ROOT_PATH"
14075   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14076     unix_path=`$CYGPATH -u "$windows_path"`
14077     MSYS_ROOT_PATH="$unix_path"
14078   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14079     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14080     MSYS_ROOT_PATH="$unix_path"
14081   fi
14082 
14083     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
14084 $as_echo "$MSYS_ROOT_PATH" >&6; }
14085     WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
14086   else
14087     as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
14088   fi
14089 
14090   # Test if windows or unix (cygwin/msys) find is first in path.
14091   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
14092 $as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
14093   FIND_BINARY_OUTPUT=`find --version 2>&1`
14094   if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
14095     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
14096 $as_echo "unix style" >&6; }
14097   elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
14098     { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
14099 $as_echo "Windows" >&6; }
14100     { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
14101 $as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
14102     { $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
14103 $as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
14104     as_fn_error $? "Cannot continue" "$LINENO" 5
14105   else
14106     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
14107 $as_echo "unknown" >&6; }
14108     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
14109 $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
14110   fi
14111 
14112   else
14113     PATH_SEP=":"
14114   fi
14115 
14116 
14117   # We get the top-level directory from the supporting wrappers.
14118   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
14119 $as_echo_n "checking for top-level directory... " >&6; }
14120   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
14121 $as_echo "$TOPDIR" >&6; }
14122 
14123 
14124   # We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
14125 
14126   # Only process if variable expands to non-empty
14127 
14128   if test "x$CURDIR" != x; then
14129     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14130 
14131   # Input might be given as Windows format, start by converting to
14132   # unix format.
14133   path="$CURDIR"
14134   new_path=`$CYGPATH -u "$path"`
14135 
14136   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14137   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14138   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14139   # "foo.exe" is OK but "foo" is an error.
14140   #
14141   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14142   # It is also a way to make sure we got the proper file name for the real test later on.
14143   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14144   if test "x$test_shortpath" = x; then
14145     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14146 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14147     as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
14148   fi
14149 
14150   # Call helper function which possibly converts this using DOS-style short mode.
14151   # If so, the updated path is stored in $new_path.
14152 
14153   input_path="$new_path"
14154   # Check if we need to convert this using DOS-style short mode. If the path
14155   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14156   # take no chances and rewrite it.
14157   # Note: m4 eats our [], so we need to use [ and ] instead.
14158   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14159   if test "x$has_forbidden_chars" != x; then
14160     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14161     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14162     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14163     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14164       # Going to short mode and back again did indeed matter. Since short mode is
14165       # case insensitive, let's make it lowercase to improve readability.
14166       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14167       # Now convert it back to Unix-stile (cygpath)
14168       input_path=`$CYGPATH -u "$shortmode_path"`
14169       new_path="$input_path"
14170     fi
14171   fi
14172 
14173   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14174   if test "x$test_cygdrive_prefix" = x; then
14175     # As a simple fix, exclude /usr/bin since it's not a real path.
14176     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14177       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14178       # a path prefixed by /cygdrive for fixpath to work.
14179       new_path="$CYGWIN_ROOT_PATH$input_path"
14180     fi
14181   fi
14182 
14183 
14184   if test "x$path" != "x$new_path"; then
14185     CURDIR="$new_path"
14186     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14187 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14188   fi
14189 
14190     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14191 
14192   path="$CURDIR"
14193   has_colon=`$ECHO $path | $GREP ^.:`
14194   new_path="$path"
14195   if test "x$has_colon" = x; then
14196     # Not in mixed or Windows style, start by that.
14197     new_path=`cmd //c echo $path`
14198   fi
14199 
14200 
14201   input_path="$new_path"
14202   # Check if we need to convert this using DOS-style short mode. If the path
14203   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14204   # take no chances and rewrite it.
14205   # Note: m4 eats our [], so we need to use [ and ] instead.
14206   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14207   if test "x$has_forbidden_chars" != x; then
14208     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14209     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14210   fi
14211 
14212 
14213   windows_path="$new_path"
14214   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14215     unix_path=`$CYGPATH -u "$windows_path"`
14216     new_path="$unix_path"
14217   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14218     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14219     new_path="$unix_path"
14220   fi
14221 
14222   if test "x$path" != "x$new_path"; then
14223     CURDIR="$new_path"
14224     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
14225 $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
14226   fi
14227 
14228   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14229   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14230 
14231     else
14232       # We're on a unix platform. Hooray! :)
14233       path="$CURDIR"
14234       has_space=`$ECHO "$path" | $GREP " "`
14235       if test "x$has_space" != x; then
14236         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
14237 $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
14238         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14239       fi
14240 
14241       # Use eval to expand a potential ~
14242       eval path="$path"
14243       if test ! -f "$path" && test ! -d "$path"; then
14244         as_fn_error $? "The path of CURDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14245       fi
14246 
14247       CURDIR="`cd "$path"; $THEPWDCMD -L`"
14248     fi
14249   fi
14250 
14251 
14252   # Only process if variable expands to non-empty
14253 
14254   if test "x$TOPDIR" != x; then
14255     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14256 
14257   # Input might be given as Windows format, start by converting to
14258   # unix format.
14259   path="$TOPDIR"
14260   new_path=`$CYGPATH -u "$path"`
14261 
14262   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14263   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14264   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14265   # "foo.exe" is OK but "foo" is an error.
14266   #
14267   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14268   # It is also a way to make sure we got the proper file name for the real test later on.
14269   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14270   if test "x$test_shortpath" = x; then
14271     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14272 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14273     as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
14274   fi
14275 
14276   # Call helper function which possibly converts this using DOS-style short mode.
14277   # If so, the updated path is stored in $new_path.
14278 
14279   input_path="$new_path"
14280   # Check if we need to convert this using DOS-style short mode. If the path
14281   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14282   # take no chances and rewrite it.
14283   # Note: m4 eats our [], so we need to use [ and ] instead.
14284   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14285   if test "x$has_forbidden_chars" != x; then
14286     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14287     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14288     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14289     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14290       # Going to short mode and back again did indeed matter. Since short mode is
14291       # case insensitive, let's make it lowercase to improve readability.
14292       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14293       # Now convert it back to Unix-stile (cygpath)
14294       input_path=`$CYGPATH -u "$shortmode_path"`
14295       new_path="$input_path"
14296     fi
14297   fi
14298 
14299   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14300   if test "x$test_cygdrive_prefix" = x; then
14301     # As a simple fix, exclude /usr/bin since it's not a real path.
14302     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14303       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14304       # a path prefixed by /cygdrive for fixpath to work.
14305       new_path="$CYGWIN_ROOT_PATH$input_path"
14306     fi
14307   fi
14308 
14309 
14310   if test "x$path" != "x$new_path"; then
14311     TOPDIR="$new_path"
14312     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14313 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14314   fi
14315 
14316     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14317 
14318   path="$TOPDIR"
14319   has_colon=`$ECHO $path | $GREP ^.:`
14320   new_path="$path"
14321   if test "x$has_colon" = x; then
14322     # Not in mixed or Windows style, start by that.
14323     new_path=`cmd //c echo $path`
14324   fi
14325 
14326 
14327   input_path="$new_path"
14328   # Check if we need to convert this using DOS-style short mode. If the path
14329   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14330   # take no chances and rewrite it.
14331   # Note: m4 eats our [], so we need to use [ and ] instead.
14332   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14333   if test "x$has_forbidden_chars" != x; then
14334     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14335     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14336   fi
14337 
14338 
14339   windows_path="$new_path"
14340   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14341     unix_path=`$CYGPATH -u "$windows_path"`
14342     new_path="$unix_path"
14343   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14344     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14345     new_path="$unix_path"
14346   fi
14347 
14348   if test "x$path" != "x$new_path"; then
14349     TOPDIR="$new_path"
14350     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
14351 $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
14352   fi
14353 
14354   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14355   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14356 
14357     else
14358       # We're on a unix platform. Hooray! :)
14359       path="$TOPDIR"
14360       has_space=`$ECHO "$path" | $GREP " "`
14361       if test "x$has_space" != x; then
14362         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
14363 $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
14364         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14365       fi
14366 
14367       # Use eval to expand a potential ~
14368       eval path="$path"
14369       if test ! -f "$path" && test ! -d "$path"; then
14370         as_fn_error $? "The path of TOPDIR, which resolves as \"$path\", is not found." "$LINENO" 5
14371       fi
14372 
14373       TOPDIR="`cd "$path"; $THEPWDCMD -L`"
14374     fi
14375   fi
14376 
14377   # SRC_ROOT is a traditional alias for TOPDIR.
14378   SRC_ROOT=$TOPDIR
14379 
14380   # Locate the directory of this script.
14381   AUTOCONF_DIR=$TOPDIR/common/autoconf
14382 
14383 
14384   # Setup default logging of stdout and stderr to build.log in the output root.
14385   BUILD_LOG='$(OUTPUT_ROOT)/build.log'
14386   BUILD_LOG_PREVIOUS='$(OUTPUT_ROOT)/build.log.old'
14387   BUILD_LOG_WRAPPER='$(BASH) $(SRC_ROOT)/common/bin/logger.sh $(BUILD_LOG)'
14388 
14389 
14390 
14391 
14392 
14393 # Check if it's a pure open build or if custom sources are to be used.
14394 
14395   # Check whether --enable-openjdk-only was given.
14396 if test "${enable_openjdk_only+set}" = set; then :
14397   enableval=$enable_openjdk_only;
14398 else
14399   enable_openjdk_only="no"
14400 fi
14401 
14402 
14403   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
14404 $as_echo_n "checking for presence of closed sources... " >&6; }
14405   if test -d "$SRC_ROOT/jdk/src/closed"; then
14406     CLOSED_SOURCE_PRESENT=yes
14407   else
14408     CLOSED_SOURCE_PRESENT=no
14409   fi
14410   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
14411 $as_echo "$CLOSED_SOURCE_PRESENT" >&6; }
14412 
14413   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
14414 $as_echo_n "checking if closed source is suppressed (openjdk-only)... " >&6; }
14415   SUPPRESS_CLOSED_SOURCE="$enable_openjdk_only"
14416   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
14417 $as_echo "$SUPPRESS_CLOSED_SOURCE" >&6; }
14418 
14419   if test "x$CLOSED_SOURCE_PRESENT" = xno; then
14420     OPENJDK=true
14421     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14422       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
14423 $as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
14424     fi
14425   else
14426     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
14427       OPENJDK=true
14428     else
14429       OPENJDK=false
14430     fi
14431   fi
14432 
14433   if test "x$OPENJDK" = "xtrue"; then
14434     SET_OPENJDK="OPENJDK=true"
14435   fi
14436 
14437 
14438 
14439   # custom-make-dir is deprecated. Please use your custom-hook.m4 to override
14440   # the IncludeCustomExtension macro.
14441 
14442 
14443 # Check whether --with-custom-make-dir was given.
14444 if test "${with_custom_make_dir+set}" = set; then :
14445   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
14446 $as_echo "$as_me: WARNING: Option --with-custom-make-dir is deprecated and will be ignored." >&2;}
14447 fi
14448 
14449 
14450 
14451 
14452 # These are needed to be able to create a configuration name (and thus the output directory)
14453 
14454   ###############################################################################
14455   #
14456   # Check which variant of the JDK that we want to build.
14457   # Currently we have:
14458   #    normal:   standard edition
14459   # but the custom make system may add other variants
14460   #
14461   # Effectively the JDK variant gives a name to a specific set of
14462   # modules to compile into the JDK. In the future, these modules
14463   # might even be Jigsaw modules.
14464   #
14465   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
14466 $as_echo_n "checking which variant of the JDK to build... " >&6; }
14467 
14468 # Check whether --with-jdk-variant was given.
14469 if test "${with_jdk_variant+set}" = set; then :
14470   withval=$with_jdk_variant;
14471 fi
14472 
14473 
14474   if test "x$with_jdk_variant" = xnormal || test "x$with_jdk_variant" = x; then
14475     JDK_VARIANT="normal"
14476   else
14477     as_fn_error $? "The available JDK variants are: normal" "$LINENO" 5
14478   fi
14479 
14480 
14481 
14482   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
14483 $as_echo "$JDK_VARIANT" >&6; }
14484 
14485 
14486 ###############################################################################
14487 #
14488 # Check which interpreter of the JVM we want to build.
14489 # Currently we have:
14490 #    template: Template interpreter (the default)
14491 #    cpp     : C++ interpreter
14492 { $as_echo "$as_me:${as_lineno-$LINENO}: checking which interpreter of the JVM to build" >&5
14493 $as_echo_n "checking which interpreter of the JVM to build... " >&6; }
14494 
14495 # Check whether --with-jvm-interpreter was given.
14496 if test "${with_jvm_interpreter+set}" = set; then :
14497   withval=$with_jvm_interpreter;
14498 fi
14499 
14500 
14501 if test "x$with_jvm_interpreter" = x; then
14502      with_jvm_interpreter="template"
14503 fi
14504 
14505 JVM_INTERPRETER="$with_jvm_interpreter"
14506 
14507 if test "x$JVM_INTERPRETER" != xtemplate && test "x$JVM_INTERPRETER" != xcpp; then
14508    as_fn_error $? "The available JVM interpreters are: template, cpp" "$LINENO" 5
14509 fi
14510 
14511 
14512 
14513 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_interpreter" >&5
14514 $as_echo "$with_jvm_interpreter" >&6; }
14515 
14516 
14517 
14518   ###############################################################################
14519   #
14520   # Check which variants of the JVM that we want to build.
14521   # Currently we have:
14522   #    server: normal interpreter and a tiered C1/C2 compiler
14523   #    client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms)
14524   #    minimal1: reduced form of client with optional VM services and features stripped out
14525   #    kernel: kernel footprint JVM that passes the TCK without major performance problems,
14526   #             ie normal interpreter and C1, only the serial GC, kernel jvmti etc
14527   #    zero: no machine code interpreter, no compiler
14528   #    zeroshark: zero interpreter and shark/llvm compiler backend
14529 #    core: interpreter only, no compiler (only works on some platforms)
14530   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
14531 $as_echo_n "checking which variants of the JVM to build... " >&6; }
14532 
14533 # Check whether --with-jvm-variants was given.
14534 if test "${with_jvm_variants+set}" = set; then :
14535   withval=$with_jvm_variants;
14536 fi
14537 
14538 
14539   if test "x$with_jvm_variants" = x; then
14540     with_jvm_variants="server"
14541   fi
14542 
14543   JVM_VARIANTS=",$with_jvm_variants,"
14544   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,//'`
14545 
14546   if test "x$TEST_VARIANTS" != "x,"; then
14547      as_fn_error $? "The available JVM variants are: server, client, minimal1, kernel, zero, zeroshark, core" "$LINENO" 5
14548   fi
14549   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5
14550 $as_echo "$with_jvm_variants" >&6; }
14551 
14552   JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'`
14553   JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'`
14554   JVM_VARIANT_MINIMAL1=`$ECHO "$JVM_VARIANTS" | $SED -e '/,minimal1,/!s/.*/false/g' -e '/,minimal1,/s/.*/true/g'`
14555   JVM_VARIANT_KERNEL=`$ECHO "$JVM_VARIANTS" | $SED -e '/,kernel,/!s/.*/false/g' -e '/,kernel,/s/.*/true/g'`
14556   JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'`
14557   JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'`
14558   JVM_VARIANT_CORE=`$ECHO "$JVM_VARIANTS" | $SED -e '/,core,/!s/.*/false/g' -e '/,core,/s/.*/true/g'`
14559 
14560   if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14561     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14562       as_fn_error $? "You cannot build a client JVM for a 64-bit machine." "$LINENO" 5
14563     fi
14564   fi
14565   if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14566     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14567       as_fn_error $? "You cannot build a kernel JVM for a 64-bit machine." "$LINENO" 5
14568     fi
14569   fi
14570   if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14571     if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
14572       as_fn_error $? "You cannot build a minimal JVM for a 64-bit machine." "$LINENO" 5
14573     fi
14574   fi
14575 
14576   # Replace the commas with AND for use in the build directory name.
14577   ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/g'`
14578   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/'`
14579   if test "x$COUNT_VARIANTS" != "x,1"; then
14580     BUILDING_MULTIPLE_JVM_VARIANTS=yes
14581   else
14582     BUILDING_MULTIPLE_JVM_VARIANTS=no
14583   fi
14584 
14585 
14586 
14587 
14588 
14589 
14590 
14591 
14592 
14593 
14594   INCLUDE_SA=true
14595   if test "x$JVM_VARIANT_ZERO" = xtrue ; then
14596     INCLUDE_SA=false
14597   fi
14598   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue ; then
14599     INCLUDE_SA=false
14600   fi
14601   if test "x$OPENJDK_TARGET_OS" = xaix ; then
14602     INCLUDE_SA=false
14603   fi
14604   if test "x$OPENJDK_TARGET_CPU" = xaarch64; then
14605     INCLUDE_SA=false
14606   fi
14607 
14608 
14609   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
14610     MACOSX_UNIVERSAL="true"
14611   fi
14612 
14613 
14614 
14615 
14616   ###############################################################################
14617   #
14618   # Set the debug level
14619   #    release: no debug information, all optimizations, no asserts.
14620   #    optimized: no debug information, all optimizations, no asserts, HotSpot target is 'optimized'.
14621   #    fastdebug: debug information (-g), all optimizations, all asserts
14622   #    slowdebug: debug information (-g), no optimizations, all asserts
14623   #
14624   DEBUG_LEVEL="release"
14625   { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
14626 $as_echo_n "checking which debug level to use... " >&6; }
14627   # Check whether --enable-debug was given.
14628 if test "${enable_debug+set}" = set; then :
14629   enableval=$enable_debug;
14630         ENABLE_DEBUG="${enableval}"
14631         DEBUG_LEVEL="fastdebug"
14632 
14633 else
14634   ENABLE_DEBUG="no"
14635 fi
14636 
14637 
14638 
14639 # Check whether --with-debug-level was given.
14640 if test "${with_debug_level+set}" = set; then :
14641   withval=$with_debug_level;
14642         DEBUG_LEVEL="${withval}"
14643         if test "x$ENABLE_DEBUG" = xyes; then
14644           as_fn_error $? "You cannot use both --enable-debug and --with-debug-level at the same time." "$LINENO" 5
14645         fi
14646 
14647 fi
14648 
14649   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
14650 $as_echo "$DEBUG_LEVEL" >&6; }
14651 
14652   if test "x$DEBUG_LEVEL" != xrelease && \
14653       test "x$DEBUG_LEVEL" != xoptimized && \
14654       test "x$DEBUG_LEVEL" != xfastdebug && \
14655       test "x$DEBUG_LEVEL" != xslowdebug; then
14656     as_fn_error $? "Allowed debug levels are: release, fastdebug and slowdebug" "$LINENO" 5
14657   fi
14658 
14659 
14660   ###############################################################################
14661   #
14662   # Setup legacy vars/targets and new vars to deal with different debug levels.
14663   #
14664 
14665   case $DEBUG_LEVEL in
14666     release )
14667       VARIANT="OPT"
14668       FASTDEBUG="false"
14669       DEBUG_CLASSFILES="false"
14670       BUILD_VARIANT_RELEASE=""
14671       HOTSPOT_DEBUG_LEVEL="product"
14672       HOTSPOT_EXPORT="product"
14673       ;;
14674     fastdebug )
14675       VARIANT="DBG"
14676       FASTDEBUG="true"
14677       DEBUG_CLASSFILES="true"
14678       BUILD_VARIANT_RELEASE="-fastdebug"
14679       HOTSPOT_DEBUG_LEVEL="fastdebug"
14680       HOTSPOT_EXPORT="fastdebug"
14681       ;;
14682     slowdebug )
14683       VARIANT="DBG"
14684       FASTDEBUG="false"
14685       DEBUG_CLASSFILES="true"
14686       BUILD_VARIANT_RELEASE="-debug"
14687       HOTSPOT_DEBUG_LEVEL="debug"
14688       HOTSPOT_EXPORT="debug"
14689       ;;
14690     optimized )
14691       VARIANT="OPT"
14692       FASTDEBUG="false"
14693       DEBUG_CLASSFILES="false"
14694       BUILD_VARIANT_RELEASE="-optimized"
14695       HOTSPOT_DEBUG_LEVEL="optimized"
14696       HOTSPOT_EXPORT="optimized"
14697       ;;
14698   esac
14699 
14700   # The debug level 'optimized' is a little special because it is currently only
14701   # applicable to the HotSpot build where it means to build a completely
14702   # optimized version of the VM without any debugging code (like for the
14703   # 'release' debug level which is called 'product' in the HotSpot build) but
14704   # with the exception that it can contain additional code which is otherwise
14705   # protected by '#ifndef PRODUCT' macros. These 'optimized' builds are used to
14706   # test new and/or experimental features which are not intended for customer
14707   # shipment. Because these new features need to be tested and benchmarked in
14708   # real world scenarios, we want to build the containing JDK at the 'release'
14709   # debug level.
14710   if test "x$DEBUG_LEVEL" = xoptimized; then
14711     DEBUG_LEVEL="release"
14712   fi
14713 
14714   #####
14715   # Generate the legacy makefile targets for hotspot.
14716   # The hotspot api for selecting the build artifacts, really, needs to be improved.
14717   # JDK-7195896 will fix this on the hotspot side by using the JVM_VARIANT_* variables to
14718   # determine what needs to be built. All we will need to set here is all_product, all_fastdebug etc
14719   # But until then ...
14720   HOTSPOT_TARGET=""
14721 
14722   if test "x$JVM_VARIANT_SERVER" = xtrue; then
14723     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL} "
14724   fi
14725 
14726   if test "x$JVM_VARIANT_CLIENT" = xtrue; then
14727     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}1 "
14728   fi
14729 
14730   if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
14731     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}minimal1 "
14732   fi
14733 
14734   if test "x$JVM_VARIANT_KERNEL" = xtrue; then
14735     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}kernel "
14736   fi
14737 
14738   if test "x$JVM_VARIANT_ZERO" = xtrue; then
14739     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}zero "
14740   fi
14741 
14742   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
14743     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}shark "
14744   fi
14745 
14746   if test "x$JVM_VARIANT_CORE" = xtrue; then
14747     HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}core "
14748   fi
14749 
14750   HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT"
14751 
14752   # On Macosx universal binaries are produced, but they only contain
14753   # 64 bit intel. This invalidates control of which jvms are built
14754   # from configure, but only server is valid anyway. Fix this
14755   # when hotspot makefiles are rewritten.
14756   if test "x$MACOSX_UNIVERSAL" = xtrue; then
14757     HOTSPOT_TARGET=universal_${HOTSPOT_EXPORT}
14758   fi
14759 
14760   #####
14761 
14762 
14763 
14764 
14765 
14766 
14767 
14768 
14769 # With basic setup done, call the custom early hook.
14770 
14771 
14772 # Check if we have devkits, extra paths or sysroot set.
14773 
14774 
14775 # Check whether --with-devkit was given.
14776 if test "${with_devkit+set}" = set; then :
14777   withval=$with_devkit;
14778 
14779   # Only process if variable expands to non-empty
14780 
14781   if test "x$with_devkit" != x; then
14782     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14783 
14784   # Input might be given as Windows format, start by converting to
14785   # unix format.
14786   path="$with_devkit"
14787   new_path=`$CYGPATH -u "$path"`
14788 
14789   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
14790   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
14791   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
14792   # "foo.exe" is OK but "foo" is an error.
14793   #
14794   # This test is therefore slightly more accurate than "test -f" to check for file precense.
14795   # It is also a way to make sure we got the proper file name for the real test later on.
14796   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
14797   if test "x$test_shortpath" = x; then
14798     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14799 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14800     as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
14801   fi
14802 
14803   # Call helper function which possibly converts this using DOS-style short mode.
14804   # If so, the updated path is stored in $new_path.
14805 
14806   input_path="$new_path"
14807   # Check if we need to convert this using DOS-style short mode. If the path
14808   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14809   # take no chances and rewrite it.
14810   # Note: m4 eats our [], so we need to use [ and ] instead.
14811   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
14812   if test "x$has_forbidden_chars" != x; then
14813     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14814     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
14815     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
14816     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
14817       # Going to short mode and back again did indeed matter. Since short mode is
14818       # case insensitive, let's make it lowercase to improve readability.
14819       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14820       # Now convert it back to Unix-stile (cygpath)
14821       input_path=`$CYGPATH -u "$shortmode_path"`
14822       new_path="$input_path"
14823     fi
14824   fi
14825 
14826   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
14827   if test "x$test_cygdrive_prefix" = x; then
14828     # As a simple fix, exclude /usr/bin since it's not a real path.
14829     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
14830       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
14831       # a path prefixed by /cygdrive for fixpath to work.
14832       new_path="$CYGWIN_ROOT_PATH$input_path"
14833     fi
14834   fi
14835 
14836 
14837   if test "x$path" != "x$new_path"; then
14838     with_devkit="$new_path"
14839     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14840 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14841   fi
14842 
14843     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14844 
14845   path="$with_devkit"
14846   has_colon=`$ECHO $path | $GREP ^.:`
14847   new_path="$path"
14848   if test "x$has_colon" = x; then
14849     # Not in mixed or Windows style, start by that.
14850     new_path=`cmd //c echo $path`
14851   fi
14852 
14853 
14854   input_path="$new_path"
14855   # Check if we need to convert this using DOS-style short mode. If the path
14856   # contains just simple characters, use it. Otherwise (spaces, weird characters),
14857   # take no chances and rewrite it.
14858   # Note: m4 eats our [], so we need to use [ and ] instead.
14859   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
14860   if test "x$has_forbidden_chars" != x; then
14861     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
14862     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
14863   fi
14864 
14865 
14866   windows_path="$new_path"
14867   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
14868     unix_path=`$CYGPATH -u "$windows_path"`
14869     new_path="$unix_path"
14870   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
14871     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
14872     new_path="$unix_path"
14873   fi
14874 
14875   if test "x$path" != "x$new_path"; then
14876     with_devkit="$new_path"
14877     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
14878 $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
14879   fi
14880 
14881   # Save the first 10 bytes of this path to the storage, so fixpath can work.
14882   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
14883 
14884     else
14885       # We're on a unix platform. Hooray! :)
14886       path="$with_devkit"
14887       has_space=`$ECHO "$path" | $GREP " "`
14888       if test "x$has_space" != x; then
14889         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
14890 $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
14891         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
14892       fi
14893 
14894       # Use eval to expand a potential ~
14895       eval path="$path"
14896       if test ! -f "$path" && test ! -d "$path"; then
14897         as_fn_error $? "The path of with_devkit, which resolves as \"$path\", is not found." "$LINENO" 5
14898       fi
14899 
14900       with_devkit="`cd "$path"; $THEPWDCMD -L`"
14901     fi
14902   fi
14903 
14904         DEVKIT_ROOT="$with_devkit"
14905         # Check for a meta data info file in the root of the devkit
14906         if test -f "$DEVKIT_ROOT/devkit.info"; then
14907           # This potentially sets the following:
14908           # DEVKIT_NAME: A descriptive name of the devkit
14909           # DEVKIT_TOOLCHAIN_PATH: Corresponds to --with-toolchain-path
14910           # DEVKIT_EXTRA_PATH: Corresponds to --with-extra-path
14911           # DEVKIT_SYSROOT: Corresponds to --with-sysroot
14912           . $DEVKIT_ROOT/devkit.info
14913         fi
14914 
14915         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
14916 $as_echo_n "checking for devkit... " >&6; }
14917         if test "x$DEVKIT_NAME" != x; then
14918           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
14919 $as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
14920         else
14921           { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
14922 $as_echo "$DEVKIT_ROOT" >&6; }
14923         fi
14924 
14925         if test "x$DEVKIT_EXTRA_PATH" != x; then
14926 
14927   if test "x$DEVKIT_EXTRA_PATH" != x; then
14928     if test "x$EXTRA_PATH" = x; then
14929       EXTRA_PATH="$DEVKIT_EXTRA_PATH"
14930     else
14931       EXTRA_PATH="$DEVKIT_EXTRA_PATH:$EXTRA_PATH"
14932     fi
14933   fi
14934 
14935         fi
14936 
14937         # Fallback default of just /bin if DEVKIT_PATH is not defined
14938         if test "x$DEVKIT_TOOLCHAIN_PATH" = x; then
14939           DEVKIT_TOOLCHAIN_PATH="$DEVKIT_ROOT/bin"
14940         fi
14941 
14942   if test "x$DEVKIT_TOOLCHAIN_PATH" != x; then
14943     if test "x$TOOLCHAIN_PATH" = x; then
14944       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH"
14945     else
14946       TOOLCHAIN_PATH="$DEVKIT_TOOLCHAIN_PATH:$TOOLCHAIN_PATH"
14947     fi
14948   fi
14949 
14950 
14951         # If DEVKIT_SYSROOT is set, use that, otherwise try a couple of known
14952         # places for backwards compatiblity.
14953         if test "x$DEVKIT_SYSROOT" != x; then
14954           SYSROOT="$DEVKIT_SYSROOT"
14955         elif test -d "$DEVKIT_ROOT/$host_alias/libc"; then
14956           SYSROOT="$DEVKIT_ROOT/$host_alias/libc"
14957         elif test -d "$DEVKIT_ROOT/$host/sys-root"; then
14958           SYSROOT="$DEVKIT_ROOT/$host/sys-root"
14959         fi
14960 
14961 
14962 fi
14963 
14964 
14965   # You can force the sysroot if the sysroot encoded into the compiler tools
14966   # is not correct.
14967 
14968 # Check whether --with-sys-root was given.
14969 if test "${with_sys_root+set}" = set; then :
14970   withval=$with_sys_root; SYSROOT=$with_sys_root
14971 
14972 fi
14973 
14974 
14975 
14976 # Check whether --with-sysroot was given.
14977 if test "${with_sysroot+set}" = set; then :
14978   withval=$with_sysroot; SYSROOT=$with_sysroot
14979 
14980 fi
14981 
14982 
14983 
14984 # Check whether --with-tools-dir was given.
14985 if test "${with_tools_dir+set}" = set; then :
14986   withval=$with_tools_dir;
14987   if test "x$with_tools_dir" != x; then
14988     if test "x$TOOLCHAIN_PATH" = x; then
14989       TOOLCHAIN_PATH="$with_tools_dir"
14990     else
14991       TOOLCHAIN_PATH="$with_tools_dir:$TOOLCHAIN_PATH"
14992     fi
14993   fi
14994 
14995 
14996 fi
14997 
14998 
14999 
15000 # Check whether --with-toolchain-path was given.
15001 if test "${with_toolchain_path+set}" = set; then :
15002   withval=$with_toolchain_path;
15003   if test "x$with_toolchain_path" != x; then
15004     if test "x$TOOLCHAIN_PATH" = x; then
15005       TOOLCHAIN_PATH="$with_toolchain_path"
15006     else
15007       TOOLCHAIN_PATH="$with_toolchain_path:$TOOLCHAIN_PATH"
15008     fi
15009   fi
15010 
15011 
15012 fi
15013 
15014 
15015 
15016 # Check whether --with-extra-path was given.
15017 if test "${with_extra_path+set}" = set; then :
15018   withval=$with_extra_path;
15019   if test "x$with_extra_path" != x; then
15020     if test "x$EXTRA_PATH" = x; then
15021       EXTRA_PATH="$with_extra_path"
15022     else
15023       EXTRA_PATH="$with_extra_path:$EXTRA_PATH"
15024     fi
15025   fi
15026 
15027 
15028 fi
15029 
15030 
15031   if test "x$OPENJDK_BUILD_OS" = "xmacosx"; then
15032     # detect if Xcode is installed by running xcodebuild -version
15033     # if no Xcode installed, xcodebuild exits with 1
15034     # if Xcode is installed, even if xcode-select is misconfigured, then it exits with 0
15035     if /usr/bin/xcodebuild -version >/dev/null 2>&1; then
15036       # We need to use xcodebuild in the toolchain dir provided by the user, this will
15037       # fall back on the stub binary in /usr/bin/xcodebuild
15038       # Extract the first word of "xcodebuild", so it can be a program name with args.
15039 set dummy xcodebuild; ac_word=$2
15040 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15041 $as_echo_n "checking for $ac_word... " >&6; }
15042 if ${ac_cv_path_XCODEBUILD+:} false; then :
15043   $as_echo_n "(cached) " >&6
15044 else
15045   case $XCODEBUILD in
15046   [\\/]* | ?:[\\/]*)
15047   ac_cv_path_XCODEBUILD="$XCODEBUILD" # Let the user override the test with a path.
15048   ;;
15049   *)
15050   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15051 for as_dir in $TOOLCHAIN_PATH
15052 do
15053   IFS=$as_save_IFS
15054   test -z "$as_dir" && as_dir=.
15055     for ac_exec_ext in '' $ac_executable_extensions; do
15056   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15057     ac_cv_path_XCODEBUILD="$as_dir/$ac_word$ac_exec_ext"
15058     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15059     break 2
15060   fi
15061 done
15062   done
15063 IFS=$as_save_IFS
15064 
15065   test -z "$ac_cv_path_XCODEBUILD" && ac_cv_path_XCODEBUILD="/usr/bin/xcodebuild"
15066   ;;
15067 esac
15068 fi
15069 XCODEBUILD=$ac_cv_path_XCODEBUILD
15070 if test -n "$XCODEBUILD"; then
15071   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XCODEBUILD" >&5
15072 $as_echo "$XCODEBUILD" >&6; }
15073 else
15074   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15075 $as_echo "no" >&6; }
15076 fi
15077 
15078 
15079     else
15080       # this should result in SYSROOT being empty, unless --with-sysroot is provided
15081       # when only the command line tools are installed there are no SDKs, so headers
15082       # are copied into the system frameworks
15083       XCODEBUILD=
15084 
15085     fi
15086 
15087     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sdk name" >&5
15088 $as_echo_n "checking for sdk name... " >&6; }
15089 
15090 # Check whether --with-sdk-name was given.
15091 if test "${with_sdk_name+set}" = set; then :
15092   withval=$with_sdk_name; SDKNAME=$with_sdk_name
15093 
15094 fi
15095 
15096     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDKNAME" >&5
15097 $as_echo "$SDKNAME" >&6; }
15098 
15099     # if toolchain path is specified then don't rely on system headers, they may not compile
15100     HAVE_SYSTEM_FRAMEWORK_HEADERS=0
15101     test -z "$TOOLCHAIN_PATH" && \
15102       HAVE_SYSTEM_FRAMEWORK_HEADERS=`test ! -f /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h; echo $?`
15103 
15104     if test -z "$SYSROOT"; then
15105       if test -n "$XCODEBUILD"; then
15106         # if we don't have system headers, use default SDK name (last resort)
15107         if test -z "$SDKNAME" -a $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
15108           SDKNAME=${SDKNAME:-macosx}
15109         fi
15110 
15111         if test -n "$SDKNAME"; then
15112           # Call xcodebuild to determine SYSROOT
15113           SYSROOT=`"$XCODEBUILD" -sdk $SDKNAME -version | grep '^Path: ' | sed 's/Path: //'`
15114         fi
15115       else
15116         if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
15117           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
15118         fi
15119       fi
15120     else
15121       # warn user if --with-sdk-name was also set
15122       if test -n "$with_sdk_name"; then
15123         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&5
15124 $as_echo "$as_me: WARNING: Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used" >&2;}
15125       fi
15126     fi
15127 
15128     if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0 -a -z "$SYSROOT"; then
15129       # If no system framework headers, then SYSROOT must be set, or we won't build
15130       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
15131     fi
15132 
15133     # Perform a basic sanity test
15134     if test ! -f "$SYSROOT/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h"; then
15135       if test -z "$SYSROOT"; then
15136         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
15137       else
15138         as_fn_error $? "Invalid SDK or SYSROOT path, dependent framework headers not found" "$LINENO" 5
15139       fi
15140     fi
15141 
15142     # set SDKROOT too, Xcode tools will pick it up
15143     SDKROOT=$SYSROOT
15144 
15145   fi
15146 
15147   # Prepend the extra path to the global path
15148 
15149   if test "x$EXTRA_PATH" != x; then
15150     if test "x$PATH" = x; then
15151       PATH="$EXTRA_PATH"
15152     else
15153       PATH="$EXTRA_PATH:$PATH"
15154     fi
15155   fi
15156 
15157 
15158   if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
15159     # Add extra search paths on solaris for utilities like ar and as etc...
15160     PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin"
15161   fi
15162 
15163   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
15164 $as_echo_n "checking for sysroot... " >&6; }
15165   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
15166 $as_echo "$SYSROOT" >&6; }
15167   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
15168 $as_echo_n "checking for toolchain path... " >&6; }
15169   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
15170 $as_echo "$TOOLCHAIN_PATH" >&6; }
15171   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
15172 $as_echo_n "checking for extra path... " >&6; }
15173   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
15174 $as_echo "$EXTRA_PATH" >&6; }
15175 
15176 
15177 # To properly create a configuration name, we need to have the OpenJDK target
15178 # and options (variants and debug level) parsed.
15179 
15180 
15181 
15182 # Check whether --with-conf-name was given.
15183 if test "${with_conf_name+set}" = set; then :
15184   withval=$with_conf_name;  CONF_NAME=${with_conf_name}
15185 fi
15186 
15187 
15188   # Test from where we are running configure, in or outside of src root.
15189   { $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
15190 $as_echo_n "checking where to store configuration... " >&6; }
15191   if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
15192       || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
15193       || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
15194     # We are running configure from the src root.
15195     # Create a default ./build/target-variant-debuglevel output root.
15196     if test "x${CONF_NAME}" = x; then
15197       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
15198 $as_echo "in default location" >&6; }
15199       CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}"
15200     else
15201       { $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
15202 $as_echo "in build directory with custom name" >&6; }
15203     fi
15204     OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
15205     $MKDIR -p "$OUTPUT_ROOT"
15206     if test ! -d "$OUTPUT_ROOT"; then
15207       as_fn_error $? "Could not create build directory $OUTPUT_ROOT" "$LINENO" 5
15208     fi
15209   else
15210     # We are running configure from outside of the src dir.
15211     # Then use the current directory as output dir!
15212     # If configuration is situated in normal build directory, just use the build
15213     # directory name as configuration name, otherwise use the complete path.
15214     if test "x${CONF_NAME}" = x; then
15215       CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
15216     fi
15217     OUTPUT_ROOT="$CURDIR"
15218     { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
15219 $as_echo "in current directory" >&6; }
15220 
15221     # WARNING: This might be a bad thing to do. You need to be sure you want to
15222     # have a configuration in this directory. Do some sanity checks!
15223 
15224     if test ! -e "$OUTPUT_ROOT/spec.gmk"; then
15225       # If we have a spec.gmk, we have run here before and we are OK. Otherwise, check for
15226       # other files
15227       files_present=`$LS $OUTPUT_ROOT`
15228       # Configure has already touched config.log and confdefs.h in the current dir when this check
15229       # is performed.
15230       filtered_files=`$ECHO "$files_present" | $SED -e 's/config.log//g' -e 's/confdefs.h//g' -e 's/ //g' \
15231       | $TR -d '\n'`
15232       if test "x$filtered_files" != x; then
15233         { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
15234 $as_echo "$as_me: Current directory is $CURDIR." >&6;}
15235         { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
15236 $as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
15237         { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
15238 $as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
15239         { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
15240 $as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
15241         { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
15242 $as_echo "$as_me: seriously mess up just about everything." >&6;}
15243         { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
15244 $as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
15245         { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
15246 $as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
15247         as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
15248       fi
15249     fi
15250   fi
15251   { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
15252 $as_echo_n "checking what configuration name to use... " >&6; }
15253   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
15254 $as_echo "$CONF_NAME" >&6; }
15255 
15256 
15257   # Only process if variable expands to non-empty
15258 
15259   if test "x$OUTPUT_ROOT" != x; then
15260     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15261 
15262   # Input might be given as Windows format, start by converting to
15263   # unix format.
15264   path="$OUTPUT_ROOT"
15265   new_path=`$CYGPATH -u "$path"`
15266 
15267   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15268   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15269   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15270   # "foo.exe" is OK but "foo" is an error.
15271   #
15272   # This test is therefore slightly more accurate than "test -f" to check for file precense.
15273   # It is also a way to make sure we got the proper file name for the real test later on.
15274   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15275   if test "x$test_shortpath" = x; then
15276     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
15277 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
15278     as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
15279   fi
15280 
15281   # Call helper function which possibly converts this using DOS-style short mode.
15282   # If so, the updated path is stored in $new_path.
15283 
15284   input_path="$new_path"
15285   # Check if we need to convert this using DOS-style short mode. If the path
15286   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15287   # take no chances and rewrite it.
15288   # Note: m4 eats our [], so we need to use [ and ] instead.
15289   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15290   if test "x$has_forbidden_chars" != x; then
15291     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15292     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15293     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15294     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15295       # Going to short mode and back again did indeed matter. Since short mode is
15296       # case insensitive, let's make it lowercase to improve readability.
15297       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15298       # Now convert it back to Unix-stile (cygpath)
15299       input_path=`$CYGPATH -u "$shortmode_path"`
15300       new_path="$input_path"
15301     fi
15302   fi
15303 
15304   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15305   if test "x$test_cygdrive_prefix" = x; then
15306     # As a simple fix, exclude /usr/bin since it's not a real path.
15307     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
15308       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15309       # a path prefixed by /cygdrive for fixpath to work.
15310       new_path="$CYGWIN_ROOT_PATH$input_path"
15311     fi
15312   fi
15313 
15314 
15315   if test "x$path" != "x$new_path"; then
15316     OUTPUT_ROOT="$new_path"
15317     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15318 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15319   fi
15320 
15321     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15322 
15323   path="$OUTPUT_ROOT"
15324   has_colon=`$ECHO $path | $GREP ^.:`
15325   new_path="$path"
15326   if test "x$has_colon" = x; then
15327     # Not in mixed or Windows style, start by that.
15328     new_path=`cmd //c echo $path`
15329   fi
15330 
15331 
15332   input_path="$new_path"
15333   # Check if we need to convert this using DOS-style short mode. If the path
15334   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15335   # take no chances and rewrite it.
15336   # Note: m4 eats our [], so we need to use [ and ] instead.
15337   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15338   if test "x$has_forbidden_chars" != x; then
15339     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15340     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15341   fi
15342 
15343 
15344   windows_path="$new_path"
15345   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15346     unix_path=`$CYGPATH -u "$windows_path"`
15347     new_path="$unix_path"
15348   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15349     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15350     new_path="$unix_path"
15351   fi
15352 
15353   if test "x$path" != "x$new_path"; then
15354     OUTPUT_ROOT="$new_path"
15355     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
15356 $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
15357   fi
15358 
15359   # Save the first 10 bytes of this path to the storage, so fixpath can work.
15360   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15361 
15362     else
15363       # We're on a unix platform. Hooray! :)
15364       path="$OUTPUT_ROOT"
15365       has_space=`$ECHO "$path" | $GREP " "`
15366       if test "x$has_space" != x; then
15367         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
15368 $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
15369         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
15370       fi
15371 
15372       # Use eval to expand a potential ~
15373       eval path="$path"
15374       if test ! -f "$path" && test ! -d "$path"; then
15375         as_fn_error $? "The path of OUTPUT_ROOT, which resolves as \"$path\", is not found." "$LINENO" 5
15376       fi
15377 
15378       OUTPUT_ROOT="`cd "$path"; $THEPWDCMD -L`"
15379     fi
15380   fi
15381 
15382 
15383   SPEC=$OUTPUT_ROOT/spec.gmk
15384 
15385   CONF_NAME=$CONF_NAME
15386 
15387   OUTPUT_ROOT=$OUTPUT_ROOT
15388 
15389 
15390   # The spec.gmk file contains all variables for the make system.
15391   ac_config_files="$ac_config_files $OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in"
15392 
15393   # The hotspot-spec.gmk file contains legacy variables for the hotspot make system.
15394   ac_config_files="$ac_config_files $OUTPUT_ROOT/hotspot-spec.gmk:$AUTOCONF_DIR/hotspot-spec.gmk.in"
15395 
15396   # The bootcycle-spec.gmk file contains support for boot cycle builds.
15397   ac_config_files="$ac_config_files $OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in"
15398 
15399   # The compare.sh is used to compare the build output to other builds.
15400   ac_config_files="$ac_config_files $OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in"
15401 
15402   # The generated Makefile knows where the spec.gmk is and where the source is.
15403   # You can run make from the OUTPUT_ROOT, or from the top-level Makefile
15404   # which will look for generated configurations
15405   ac_config_files="$ac_config_files $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in"
15406 
15407 
15408 
15409 # Must be done before we can call HELP_MSG_MISSING_DEPENDENCY.
15410 
15411   for ac_prog in apt-get yum port pkgutil pkgadd
15412 do
15413   # Extract the first word of "$ac_prog", so it can be a program name with args.
15414 set dummy $ac_prog; ac_word=$2
15415 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15416 $as_echo_n "checking for $ac_word... " >&6; }
15417 if ${ac_cv_prog_PKGHANDLER+:} false; then :
15418   $as_echo_n "(cached) " >&6
15419 else
15420   if test -n "$PKGHANDLER"; then
15421   ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
15422 else
15423 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15424 for as_dir in $PATH
15425 do
15426   IFS=$as_save_IFS
15427   test -z "$as_dir" && as_dir=.
15428     for ac_exec_ext in '' $ac_executable_extensions; do
15429   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15430     ac_cv_prog_PKGHANDLER="$ac_prog"
15431     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15432     break 2
15433   fi
15434 done
15435   done
15436 IFS=$as_save_IFS
15437 
15438 fi
15439 fi
15440 PKGHANDLER=$ac_cv_prog_PKGHANDLER
15441 if test -n "$PKGHANDLER"; then
15442   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
15443 $as_echo "$PKGHANDLER" >&6; }
15444 else
15445   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15446 $as_echo "no" >&6; }
15447 fi
15448 
15449 
15450   test -n "$PKGHANDLER" && break
15451 done
15452 
15453 
15454 
15455 # Setup tools that requires more complex handling, or that is not needed by the configure script.
15456 
15457 
15458   # We need to find a recent version of GNU make. Especially on Solaris, this can be tricky.
15459   if test "x$MAKE" != x; then
15460     # User has supplied a make, test it.
15461     if test ! -f "$MAKE"; then
15462       as_fn_error $? "The specified make (by MAKE=$MAKE) is not found." "$LINENO" 5
15463     fi
15464 
15465   MAKE_CANDIDATE=""$MAKE""
15466   DESCRIPTION="user supplied MAKE=$MAKE"
15467   if test "x$MAKE_CANDIDATE" != x; then
15468     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15469 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15470     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15471     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15472     if test "x$IS_GNU_MAKE" = x; then
15473       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15474 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15475     else
15476       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15477       if test "x$IS_MODERN_MAKE" = x; then
15478         { $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
15479 $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;}
15480       else
15481         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15482           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15483             MAKE_EXPECTED_ENV='cygwin'
15484           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15485             MAKE_EXPECTED_ENV='msys'
15486           else
15487             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15488           fi
15489           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15490           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15491         else
15492           # Not relevant for non-Windows
15493           IS_MAKE_CORRECT_ENV=true
15494         fi
15495         if test "x$IS_MAKE_CORRECT_ENV" = x; then
15496           { $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
15497 $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;}
15498         else
15499           FOUND_MAKE=$MAKE_CANDIDATE
15500 
15501   # Only process if variable expands to non-empty
15502 
15503   if test "x$FOUND_MAKE" != x; then
15504     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15505 
15506   # First separate the path from the arguments. This will split at the first
15507   # space.
15508   complete="$FOUND_MAKE"
15509   path="${complete%% *}"
15510   tmp="$complete EOL"
15511   arguments="${tmp#* }"
15512 
15513   # Input might be given as Windows format, start by converting to
15514   # unix format.
15515   new_path=`$CYGPATH -u "$path"`
15516 
15517   # Now try to locate executable using which
15518   new_path=`$WHICH "$new_path" 2> /dev/null`
15519   # bat and cmd files are not always considered executable in cygwin causing which
15520   # to not find them
15521   if test "x$new_path" = x \
15522       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15523       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15524     new_path=`$CYGPATH -u "$path"`
15525   fi
15526   if test "x$new_path" = x; then
15527     # Oops. Which didn't find the executable.
15528     # The splitting of arguments from the executable at a space might have been incorrect,
15529     # since paths with space are more likely in Windows. Give it another try with the whole
15530     # argument.
15531     path="$complete"
15532     arguments="EOL"
15533     new_path=`$CYGPATH -u "$path"`
15534     new_path=`$WHICH "$new_path" 2> /dev/null`
15535     # bat and cmd files are not always considered executable in cygwin causing which
15536     # to not find them
15537     if test "x$new_path" = x \
15538         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15539         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15540       new_path=`$CYGPATH -u "$path"`
15541     fi
15542     if test "x$new_path" = x; then
15543       # It's still not found. Now this is an unrecoverable error.
15544       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15545 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15546       has_space=`$ECHO "$complete" | $GREP " "`
15547       if test "x$has_space" != x; then
15548         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15549 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15550       fi
15551       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15552     fi
15553   fi
15554 
15555   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15556   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15557   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15558   # "foo.exe" is OK but "foo" is an error.
15559   #
15560   # This test is therefore slightly more accurate than "test -f" to check for file presence.
15561   # It is also a way to make sure we got the proper file name for the real test later on.
15562   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15563   if test "x$test_shortpath" = x; then
15564     # Short path failed, file does not exist as specified.
15565     # Try adding .exe or .cmd
15566     if test -f "${new_path}.exe"; then
15567       input_to_shortpath="${new_path}.exe"
15568     elif test -f "${new_path}.cmd"; then
15569       input_to_shortpath="${new_path}.cmd"
15570     else
15571       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15572 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15573       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15574 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15575       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15576     fi
15577   else
15578     input_to_shortpath="$new_path"
15579   fi
15580 
15581   # Call helper function which possibly converts this using DOS-style short mode.
15582   # If so, the updated path is stored in $new_path.
15583   new_path="$input_to_shortpath"
15584 
15585   input_path="$input_to_shortpath"
15586   # Check if we need to convert this using DOS-style short mode. If the path
15587   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15588   # take no chances and rewrite it.
15589   # Note: m4 eats our [], so we need to use [ and ] instead.
15590   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15591   if test "x$has_forbidden_chars" != x; then
15592     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15593     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15594     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15595     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15596       # Going to short mode and back again did indeed matter. Since short mode is
15597       # case insensitive, let's make it lowercase to improve readability.
15598       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15599       # Now convert it back to Unix-stile (cygpath)
15600       input_path=`$CYGPATH -u "$shortmode_path"`
15601       new_path="$input_path"
15602     fi
15603   fi
15604 
15605   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15606   if test "x$test_cygdrive_prefix" = x; then
15607     # As a simple fix, exclude /usr/bin since it's not a real path.
15608     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15609       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15610       # a path prefixed by /cygdrive for fixpath to work.
15611       new_path="$CYGWIN_ROOT_PATH$input_path"
15612     fi
15613   fi
15614 
15615   # remove trailing .exe if any
15616   new_path="${new_path/%.exe/}"
15617 
15618     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15619 
15620   # First separate the path from the arguments. This will split at the first
15621   # space.
15622   complete="$FOUND_MAKE"
15623   path="${complete%% *}"
15624   tmp="$complete EOL"
15625   arguments="${tmp#* }"
15626 
15627   # Input might be given as Windows format, start by converting to
15628   # unix format.
15629   new_path="$path"
15630 
15631   windows_path="$new_path"
15632   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15633     unix_path=`$CYGPATH -u "$windows_path"`
15634     new_path="$unix_path"
15635   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15636     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15637     new_path="$unix_path"
15638   fi
15639 
15640 
15641   # Now try to locate executable using which
15642   new_path=`$WHICH "$new_path" 2> /dev/null`
15643 
15644   if test "x$new_path" = x; then
15645     # Oops. Which didn't find the executable.
15646     # The splitting of arguments from the executable at a space might have been incorrect,
15647     # since paths with space are more likely in Windows. Give it another try with the whole
15648     # argument.
15649     path="$complete"
15650     arguments="EOL"
15651     new_path="$path"
15652 
15653   windows_path="$new_path"
15654   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15655     unix_path=`$CYGPATH -u "$windows_path"`
15656     new_path="$unix_path"
15657   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15658     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15659     new_path="$unix_path"
15660   fi
15661 
15662 
15663     new_path=`$WHICH "$new_path" 2> /dev/null`
15664     # bat and cmd files are not always considered executable in MSYS causing which
15665     # to not find them
15666     if test "x$new_path" = x \
15667         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15668         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15669       new_path="$path"
15670 
15671   windows_path="$new_path"
15672   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15673     unix_path=`$CYGPATH -u "$windows_path"`
15674     new_path="$unix_path"
15675   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15676     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15677     new_path="$unix_path"
15678   fi
15679 
15680     fi
15681 
15682     if test "x$new_path" = x; then
15683       # It's still not found. Now this is an unrecoverable error.
15684       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15685 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15686       has_space=`$ECHO "$complete" | $GREP " "`
15687       if test "x$has_space" != x; then
15688         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15689 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15690       fi
15691       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15692     fi
15693   fi
15694 
15695   # Now new_path has a complete unix path to the binary
15696   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
15697     # Keep paths in /bin as-is, but remove trailing .exe if any
15698     new_path="${new_path/%.exe/}"
15699     # Do not save /bin paths to all_fixpath_prefixes!
15700   else
15701     # Not in mixed or Windows style, start by that.
15702     new_path=`cmd //c echo $new_path`
15703 
15704   input_path="$new_path"
15705   # Check if we need to convert this using DOS-style short mode. If the path
15706   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15707   # take no chances and rewrite it.
15708   # Note: m4 eats our [], so we need to use [ and ] instead.
15709   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
15710   if test "x$has_forbidden_chars" != x; then
15711     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15712     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15713   fi
15714 
15715     # Output is in $new_path
15716 
15717   windows_path="$new_path"
15718   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15719     unix_path=`$CYGPATH -u "$windows_path"`
15720     new_path="$unix_path"
15721   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15722     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
15723     new_path="$unix_path"
15724   fi
15725 
15726     # remove trailing .exe if any
15727     new_path="${new_path/%.exe/}"
15728 
15729     # Save the first 10 bytes of this path to the storage, so fixpath can work.
15730     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
15731   fi
15732 
15733     else
15734       # We're on a unix platform. Hooray! :)
15735       # First separate the path from the arguments. This will split at the first
15736       # space.
15737       complete="$FOUND_MAKE"
15738       path="${complete%% *}"
15739       tmp="$complete EOL"
15740       arguments="${tmp#* }"
15741 
15742       # Cannot rely on the command "which" here since it doesn't always work.
15743       is_absolute_path=`$ECHO "$path" | $GREP ^/`
15744       if test -z "$is_absolute_path"; then
15745         # Path to executable is not absolute. Find it.
15746         IFS_save="$IFS"
15747         IFS=:
15748         for p in $PATH; do
15749           if test -f "$p/$path" && test -x "$p/$path"; then
15750             new_path="$p/$path"
15751             break
15752           fi
15753         done
15754         IFS="$IFS_save"
15755       else
15756         # This is an absolute path, we can use it without further modifications.
15757         new_path="$path"
15758       fi
15759 
15760       if test "x$new_path" = x; then
15761         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15762 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15763         has_space=`$ECHO "$complete" | $GREP " "`
15764         if test "x$has_space" != x; then
15765           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
15766 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
15767         fi
15768         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15769       fi
15770     fi
15771 
15772     # Now join together the path and the arguments once again
15773     if test "x$arguments" != xEOL; then
15774       new_complete="$new_path ${arguments% *}"
15775     else
15776       new_complete="$new_path"
15777     fi
15778 
15779     if test "x$complete" != "x$new_complete"; then
15780       FOUND_MAKE="$new_complete"
15781       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
15782 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
15783     fi
15784   fi
15785 
15786         fi
15787       fi
15788     fi
15789   fi
15790 
15791     if test "x$FOUND_MAKE" = x; then
15792       as_fn_error $? "The specified make (by MAKE=$MAKE) is not GNU make 3.81 or newer." "$LINENO" 5
15793     fi
15794   else
15795     # Try our hardest to locate a correct version of GNU make
15796     for ac_prog in gmake
15797 do
15798   # Extract the first word of "$ac_prog", so it can be a program name with args.
15799 set dummy $ac_prog; ac_word=$2
15800 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
15801 $as_echo_n "checking for $ac_word... " >&6; }
15802 if ${ac_cv_path_CHECK_GMAKE+:} false; then :
15803   $as_echo_n "(cached) " >&6
15804 else
15805   case $CHECK_GMAKE in
15806   [\\/]* | ?:[\\/]*)
15807   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
15808   ;;
15809   *)
15810   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
15811 for as_dir in $PATH
15812 do
15813   IFS=$as_save_IFS
15814   test -z "$as_dir" && as_dir=.
15815     for ac_exec_ext in '' $ac_executable_extensions; do
15816   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
15817     ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
15818     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
15819     break 2
15820   fi
15821 done
15822   done
15823 IFS=$as_save_IFS
15824 
15825   ;;
15826 esac
15827 fi
15828 CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
15829 if test -n "$CHECK_GMAKE"; then
15830   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
15831 $as_echo "$CHECK_GMAKE" >&6; }
15832 else
15833   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
15834 $as_echo "no" >&6; }
15835 fi
15836 
15837 
15838   test -n "$CHECK_GMAKE" && break
15839 done
15840 
15841 
15842   MAKE_CANDIDATE=""$CHECK_GMAKE""
15843   DESCRIPTION="gmake in PATH"
15844   if test "x$MAKE_CANDIDATE" != x; then
15845     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
15846 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
15847     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
15848     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
15849     if test "x$IS_GNU_MAKE" = x; then
15850       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
15851 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
15852     else
15853       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
15854       if test "x$IS_MODERN_MAKE" = x; then
15855         { $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
15856 $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;}
15857       else
15858         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
15859           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15860             MAKE_EXPECTED_ENV='cygwin'
15861           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15862             MAKE_EXPECTED_ENV='msys'
15863           else
15864             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
15865           fi
15866           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
15867           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
15868         else
15869           # Not relevant for non-Windows
15870           IS_MAKE_CORRECT_ENV=true
15871         fi
15872         if test "x$IS_MAKE_CORRECT_ENV" = x; then
15873           { $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
15874 $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;}
15875         else
15876           FOUND_MAKE=$MAKE_CANDIDATE
15877 
15878   # Only process if variable expands to non-empty
15879 
15880   if test "x$FOUND_MAKE" != x; then
15881     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
15882 
15883   # First separate the path from the arguments. This will split at the first
15884   # space.
15885   complete="$FOUND_MAKE"
15886   path="${complete%% *}"
15887   tmp="$complete EOL"
15888   arguments="${tmp#* }"
15889 
15890   # Input might be given as Windows format, start by converting to
15891   # unix format.
15892   new_path=`$CYGPATH -u "$path"`
15893 
15894   # Now try to locate executable using which
15895   new_path=`$WHICH "$new_path" 2> /dev/null`
15896   # bat and cmd files are not always considered executable in cygwin causing which
15897   # to not find them
15898   if test "x$new_path" = x \
15899       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15900       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15901     new_path=`$CYGPATH -u "$path"`
15902   fi
15903   if test "x$new_path" = x; then
15904     # Oops. Which didn't find the executable.
15905     # The splitting of arguments from the executable at a space might have been incorrect,
15906     # since paths with space are more likely in Windows. Give it another try with the whole
15907     # argument.
15908     path="$complete"
15909     arguments="EOL"
15910     new_path=`$CYGPATH -u "$path"`
15911     new_path=`$WHICH "$new_path" 2> /dev/null`
15912     # bat and cmd files are not always considered executable in cygwin causing which
15913     # to not find them
15914     if test "x$new_path" = x \
15915         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
15916         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
15917       new_path=`$CYGPATH -u "$path"`
15918     fi
15919     if test "x$new_path" = x; then
15920       # It's still not found. Now this is an unrecoverable error.
15921       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
15922 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
15923       has_space=`$ECHO "$complete" | $GREP " "`
15924       if test "x$has_space" != x; then
15925         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
15926 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
15927       fi
15928       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15929     fi
15930   fi
15931 
15932   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
15933   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
15934   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
15935   # "foo.exe" is OK but "foo" is an error.
15936   #
15937   # This test is therefore slightly more accurate than "test -f" to check for file presence.
15938   # It is also a way to make sure we got the proper file name for the real test later on.
15939   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
15940   if test "x$test_shortpath" = x; then
15941     # Short path failed, file does not exist as specified.
15942     # Try adding .exe or .cmd
15943     if test -f "${new_path}.exe"; then
15944       input_to_shortpath="${new_path}.exe"
15945     elif test -f "${new_path}.cmd"; then
15946       input_to_shortpath="${new_path}.cmd"
15947     else
15948       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
15949 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
15950       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
15951 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
15952       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
15953     fi
15954   else
15955     input_to_shortpath="$new_path"
15956   fi
15957 
15958   # Call helper function which possibly converts this using DOS-style short mode.
15959   # If so, the updated path is stored in $new_path.
15960   new_path="$input_to_shortpath"
15961 
15962   input_path="$input_to_shortpath"
15963   # Check if we need to convert this using DOS-style short mode. If the path
15964   # contains just simple characters, use it. Otherwise (spaces, weird characters),
15965   # take no chances and rewrite it.
15966   # Note: m4 eats our [], so we need to use [ and ] instead.
15967   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
15968   if test "x$has_forbidden_chars" != x; then
15969     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
15970     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
15971     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
15972     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
15973       # Going to short mode and back again did indeed matter. Since short mode is
15974       # case insensitive, let's make it lowercase to improve readability.
15975       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
15976       # Now convert it back to Unix-stile (cygpath)
15977       input_path=`$CYGPATH -u "$shortmode_path"`
15978       new_path="$input_path"
15979     fi
15980   fi
15981 
15982   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
15983   if test "x$test_cygdrive_prefix" = x; then
15984     # As a simple fix, exclude /usr/bin since it's not a real path.
15985     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
15986       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
15987       # a path prefixed by /cygdrive for fixpath to work.
15988       new_path="$CYGWIN_ROOT_PATH$input_path"
15989     fi
15990   fi
15991 
15992   # remove trailing .exe if any
15993   new_path="${new_path/%.exe/}"
15994 
15995     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
15996 
15997   # First separate the path from the arguments. This will split at the first
15998   # space.
15999   complete="$FOUND_MAKE"
16000   path="${complete%% *}"
16001   tmp="$complete EOL"
16002   arguments="${tmp#* }"
16003 
16004   # Input might be given as Windows format, start by converting to
16005   # unix format.
16006   new_path="$path"
16007 
16008   windows_path="$new_path"
16009   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16010     unix_path=`$CYGPATH -u "$windows_path"`
16011     new_path="$unix_path"
16012   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16013     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16014     new_path="$unix_path"
16015   fi
16016 
16017 
16018   # Now try to locate executable using which
16019   new_path=`$WHICH "$new_path" 2> /dev/null`
16020 
16021   if test "x$new_path" = x; then
16022     # Oops. Which didn't find the executable.
16023     # The splitting of arguments from the executable at a space might have been incorrect,
16024     # since paths with space are more likely in Windows. Give it another try with the whole
16025     # argument.
16026     path="$complete"
16027     arguments="EOL"
16028     new_path="$path"
16029 
16030   windows_path="$new_path"
16031   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16032     unix_path=`$CYGPATH -u "$windows_path"`
16033     new_path="$unix_path"
16034   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16035     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16036     new_path="$unix_path"
16037   fi
16038 
16039 
16040     new_path=`$WHICH "$new_path" 2> /dev/null`
16041     # bat and cmd files are not always considered executable in MSYS causing which
16042     # to not find them
16043     if test "x$new_path" = x \
16044         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16045         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16046       new_path="$path"
16047 
16048   windows_path="$new_path"
16049   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16050     unix_path=`$CYGPATH -u "$windows_path"`
16051     new_path="$unix_path"
16052   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16053     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16054     new_path="$unix_path"
16055   fi
16056 
16057     fi
16058 
16059     if test "x$new_path" = x; then
16060       # It's still not found. Now this is an unrecoverable error.
16061       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16062 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16063       has_space=`$ECHO "$complete" | $GREP " "`
16064       if test "x$has_space" != x; then
16065         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16066 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16067       fi
16068       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16069     fi
16070   fi
16071 
16072   # Now new_path has a complete unix path to the binary
16073   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16074     # Keep paths in /bin as-is, but remove trailing .exe if any
16075     new_path="${new_path/%.exe/}"
16076     # Do not save /bin paths to all_fixpath_prefixes!
16077   else
16078     # Not in mixed or Windows style, start by that.
16079     new_path=`cmd //c echo $new_path`
16080 
16081   input_path="$new_path"
16082   # Check if we need to convert this using DOS-style short mode. If the path
16083   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16084   # take no chances and rewrite it.
16085   # Note: m4 eats our [], so we need to use [ and ] instead.
16086   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16087   if test "x$has_forbidden_chars" != x; then
16088     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16089     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16090   fi
16091 
16092     # Output is in $new_path
16093 
16094   windows_path="$new_path"
16095   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16096     unix_path=`$CYGPATH -u "$windows_path"`
16097     new_path="$unix_path"
16098   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16099     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16100     new_path="$unix_path"
16101   fi
16102 
16103     # remove trailing .exe if any
16104     new_path="${new_path/%.exe/}"
16105 
16106     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16107     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16108   fi
16109 
16110     else
16111       # We're on a unix platform. Hooray! :)
16112       # First separate the path from the arguments. This will split at the first
16113       # space.
16114       complete="$FOUND_MAKE"
16115       path="${complete%% *}"
16116       tmp="$complete EOL"
16117       arguments="${tmp#* }"
16118 
16119       # Cannot rely on the command "which" here since it doesn't always work.
16120       is_absolute_path=`$ECHO "$path" | $GREP ^/`
16121       if test -z "$is_absolute_path"; then
16122         # Path to executable is not absolute. Find it.
16123         IFS_save="$IFS"
16124         IFS=:
16125         for p in $PATH; do
16126           if test -f "$p/$path" && test -x "$p/$path"; then
16127             new_path="$p/$path"
16128             break
16129           fi
16130         done
16131         IFS="$IFS_save"
16132       else
16133         # This is an absolute path, we can use it without further modifications.
16134         new_path="$path"
16135       fi
16136 
16137       if test "x$new_path" = x; then
16138         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16139 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16140         has_space=`$ECHO "$complete" | $GREP " "`
16141         if test "x$has_space" != x; then
16142           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16143 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16144         fi
16145         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16146       fi
16147     fi
16148 
16149     # Now join together the path and the arguments once again
16150     if test "x$arguments" != xEOL; then
16151       new_complete="$new_path ${arguments% *}"
16152     else
16153       new_complete="$new_path"
16154     fi
16155 
16156     if test "x$complete" != "x$new_complete"; then
16157       FOUND_MAKE="$new_complete"
16158       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16159 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16160     fi
16161   fi
16162 
16163         fi
16164       fi
16165     fi
16166   fi
16167 
16168 
16169     if test "x$FOUND_MAKE" = x; then
16170       for ac_prog in make
16171 do
16172   # Extract the first word of "$ac_prog", so it can be a program name with args.
16173 set dummy $ac_prog; ac_word=$2
16174 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16175 $as_echo_n "checking for $ac_word... " >&6; }
16176 if ${ac_cv_path_CHECK_MAKE+:} false; then :
16177   $as_echo_n "(cached) " >&6
16178 else
16179   case $CHECK_MAKE in
16180   [\\/]* | ?:[\\/]*)
16181   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
16182   ;;
16183   *)
16184   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16185 for as_dir in $PATH
16186 do
16187   IFS=$as_save_IFS
16188   test -z "$as_dir" && as_dir=.
16189     for ac_exec_ext in '' $ac_executable_extensions; do
16190   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16191     ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
16192     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16193     break 2
16194   fi
16195 done
16196   done
16197 IFS=$as_save_IFS
16198 
16199   ;;
16200 esac
16201 fi
16202 CHECK_MAKE=$ac_cv_path_CHECK_MAKE
16203 if test -n "$CHECK_MAKE"; then
16204   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
16205 $as_echo "$CHECK_MAKE" >&6; }
16206 else
16207   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16208 $as_echo "no" >&6; }
16209 fi
16210 
16211 
16212   test -n "$CHECK_MAKE" && break
16213 done
16214 
16215 
16216   MAKE_CANDIDATE=""$CHECK_MAKE""
16217   DESCRIPTION="make in PATH"
16218   if test "x$MAKE_CANDIDATE" != x; then
16219     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16220 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16221     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16222     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16223     if test "x$IS_GNU_MAKE" = x; then
16224       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16225 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16226     else
16227       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
16228       if test "x$IS_MODERN_MAKE" = x; then
16229         { $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
16230 $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;}
16231       else
16232         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16233           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16234             MAKE_EXPECTED_ENV='cygwin'
16235           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16236             MAKE_EXPECTED_ENV='msys'
16237           else
16238             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16239           fi
16240           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16241           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16242         else
16243           # Not relevant for non-Windows
16244           IS_MAKE_CORRECT_ENV=true
16245         fi
16246         if test "x$IS_MAKE_CORRECT_ENV" = x; then
16247           { $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
16248 $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;}
16249         else
16250           FOUND_MAKE=$MAKE_CANDIDATE
16251 
16252   # Only process if variable expands to non-empty
16253 
16254   if test "x$FOUND_MAKE" != x; then
16255     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16256 
16257   # First separate the path from the arguments. This will split at the first
16258   # space.
16259   complete="$FOUND_MAKE"
16260   path="${complete%% *}"
16261   tmp="$complete EOL"
16262   arguments="${tmp#* }"
16263 
16264   # Input might be given as Windows format, start by converting to
16265   # unix format.
16266   new_path=`$CYGPATH -u "$path"`
16267 
16268   # Now try to locate executable using which
16269   new_path=`$WHICH "$new_path" 2> /dev/null`
16270   # bat and cmd files are not always considered executable in cygwin causing which
16271   # to not find them
16272   if test "x$new_path" = x \
16273       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16274       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16275     new_path=`$CYGPATH -u "$path"`
16276   fi
16277   if test "x$new_path" = x; then
16278     # Oops. Which didn't find the executable.
16279     # The splitting of arguments from the executable at a space might have been incorrect,
16280     # since paths with space are more likely in Windows. Give it another try with the whole
16281     # argument.
16282     path="$complete"
16283     arguments="EOL"
16284     new_path=`$CYGPATH -u "$path"`
16285     new_path=`$WHICH "$new_path" 2> /dev/null`
16286     # bat and cmd files are not always considered executable in cygwin causing which
16287     # to not find them
16288     if test "x$new_path" = x \
16289         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16290         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16291       new_path=`$CYGPATH -u "$path"`
16292     fi
16293     if test "x$new_path" = x; then
16294       # It's still not found. Now this is an unrecoverable error.
16295       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16296 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16297       has_space=`$ECHO "$complete" | $GREP " "`
16298       if test "x$has_space" != x; then
16299         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16300 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16301       fi
16302       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16303     fi
16304   fi
16305 
16306   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16307   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16308   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16309   # "foo.exe" is OK but "foo" is an error.
16310   #
16311   # This test is therefore slightly more accurate than "test -f" to check for file presence.
16312   # It is also a way to make sure we got the proper file name for the real test later on.
16313   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16314   if test "x$test_shortpath" = x; then
16315     # Short path failed, file does not exist as specified.
16316     # Try adding .exe or .cmd
16317     if test -f "${new_path}.exe"; then
16318       input_to_shortpath="${new_path}.exe"
16319     elif test -f "${new_path}.cmd"; then
16320       input_to_shortpath="${new_path}.cmd"
16321     else
16322       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16323 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16324       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16325 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16326       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16327     fi
16328   else
16329     input_to_shortpath="$new_path"
16330   fi
16331 
16332   # Call helper function which possibly converts this using DOS-style short mode.
16333   # If so, the updated path is stored in $new_path.
16334   new_path="$input_to_shortpath"
16335 
16336   input_path="$input_to_shortpath"
16337   # Check if we need to convert this using DOS-style short mode. If the path
16338   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16339   # take no chances and rewrite it.
16340   # Note: m4 eats our [], so we need to use [ and ] instead.
16341   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16342   if test "x$has_forbidden_chars" != x; then
16343     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16344     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16345     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16346     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16347       # Going to short mode and back again did indeed matter. Since short mode is
16348       # case insensitive, let's make it lowercase to improve readability.
16349       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16350       # Now convert it back to Unix-stile (cygpath)
16351       input_path=`$CYGPATH -u "$shortmode_path"`
16352       new_path="$input_path"
16353     fi
16354   fi
16355 
16356   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16357   if test "x$test_cygdrive_prefix" = x; then
16358     # As a simple fix, exclude /usr/bin since it's not a real path.
16359     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16360       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16361       # a path prefixed by /cygdrive for fixpath to work.
16362       new_path="$CYGWIN_ROOT_PATH$input_path"
16363     fi
16364   fi
16365 
16366   # remove trailing .exe if any
16367   new_path="${new_path/%.exe/}"
16368 
16369     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16370 
16371   # First separate the path from the arguments. This will split at the first
16372   # space.
16373   complete="$FOUND_MAKE"
16374   path="${complete%% *}"
16375   tmp="$complete EOL"
16376   arguments="${tmp#* }"
16377 
16378   # Input might be given as Windows format, start by converting to
16379   # unix format.
16380   new_path="$path"
16381 
16382   windows_path="$new_path"
16383   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16384     unix_path=`$CYGPATH -u "$windows_path"`
16385     new_path="$unix_path"
16386   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16387     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16388     new_path="$unix_path"
16389   fi
16390 
16391 
16392   # Now try to locate executable using which
16393   new_path=`$WHICH "$new_path" 2> /dev/null`
16394 
16395   if test "x$new_path" = x; then
16396     # Oops. Which didn't find the executable.
16397     # The splitting of arguments from the executable at a space might have been incorrect,
16398     # since paths with space are more likely in Windows. Give it another try with the whole
16399     # argument.
16400     path="$complete"
16401     arguments="EOL"
16402     new_path="$path"
16403 
16404   windows_path="$new_path"
16405   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16406     unix_path=`$CYGPATH -u "$windows_path"`
16407     new_path="$unix_path"
16408   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16409     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16410     new_path="$unix_path"
16411   fi
16412 
16413 
16414     new_path=`$WHICH "$new_path" 2> /dev/null`
16415     # bat and cmd files are not always considered executable in MSYS causing which
16416     # to not find them
16417     if test "x$new_path" = x \
16418         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16419         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16420       new_path="$path"
16421 
16422   windows_path="$new_path"
16423   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16424     unix_path=`$CYGPATH -u "$windows_path"`
16425     new_path="$unix_path"
16426   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16427     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16428     new_path="$unix_path"
16429   fi
16430 
16431     fi
16432 
16433     if test "x$new_path" = x; then
16434       # It's still not found. Now this is an unrecoverable error.
16435       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16436 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16437       has_space=`$ECHO "$complete" | $GREP " "`
16438       if test "x$has_space" != x; then
16439         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16440 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16441       fi
16442       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16443     fi
16444   fi
16445 
16446   # Now new_path has a complete unix path to the binary
16447   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16448     # Keep paths in /bin as-is, but remove trailing .exe if any
16449     new_path="${new_path/%.exe/}"
16450     # Do not save /bin paths to all_fixpath_prefixes!
16451   else
16452     # Not in mixed or Windows style, start by that.
16453     new_path=`cmd //c echo $new_path`
16454 
16455   input_path="$new_path"
16456   # Check if we need to convert this using DOS-style short mode. If the path
16457   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16458   # take no chances and rewrite it.
16459   # Note: m4 eats our [], so we need to use [ and ] instead.
16460   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16461   if test "x$has_forbidden_chars" != x; then
16462     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16463     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16464   fi
16465 
16466     # Output is in $new_path
16467 
16468   windows_path="$new_path"
16469   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16470     unix_path=`$CYGPATH -u "$windows_path"`
16471     new_path="$unix_path"
16472   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16473     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16474     new_path="$unix_path"
16475   fi
16476 
16477     # remove trailing .exe if any
16478     new_path="${new_path/%.exe/}"
16479 
16480     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16481     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16482   fi
16483 
16484     else
16485       # We're on a unix platform. Hooray! :)
16486       # First separate the path from the arguments. This will split at the first
16487       # space.
16488       complete="$FOUND_MAKE"
16489       path="${complete%% *}"
16490       tmp="$complete EOL"
16491       arguments="${tmp#* }"
16492 
16493       # Cannot rely on the command "which" here since it doesn't always work.
16494       is_absolute_path=`$ECHO "$path" | $GREP ^/`
16495       if test -z "$is_absolute_path"; then
16496         # Path to executable is not absolute. Find it.
16497         IFS_save="$IFS"
16498         IFS=:
16499         for p in $PATH; do
16500           if test -f "$p/$path" && test -x "$p/$path"; then
16501             new_path="$p/$path"
16502             break
16503           fi
16504         done
16505         IFS="$IFS_save"
16506       else
16507         # This is an absolute path, we can use it without further modifications.
16508         new_path="$path"
16509       fi
16510 
16511       if test "x$new_path" = x; then
16512         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16513 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16514         has_space=`$ECHO "$complete" | $GREP " "`
16515         if test "x$has_space" != x; then
16516           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16517 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16518         fi
16519         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16520       fi
16521     fi
16522 
16523     # Now join together the path and the arguments once again
16524     if test "x$arguments" != xEOL; then
16525       new_complete="$new_path ${arguments% *}"
16526     else
16527       new_complete="$new_path"
16528     fi
16529 
16530     if test "x$complete" != "x$new_complete"; then
16531       FOUND_MAKE="$new_complete"
16532       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16533 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16534     fi
16535   fi
16536 
16537         fi
16538       fi
16539     fi
16540   fi
16541 
16542     fi
16543 
16544     if test "x$FOUND_MAKE" = x; then
16545       if test "x$TOOLCHAIN_PATH" != x; then
16546         # We have a toolchain path, check that as well before giving up.
16547         OLD_PATH=$PATH
16548         PATH=$TOOLCHAIN_PATH:$PATH
16549         for ac_prog in gmake
16550 do
16551   # Extract the first word of "$ac_prog", so it can be a program name with args.
16552 set dummy $ac_prog; ac_word=$2
16553 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16554 $as_echo_n "checking for $ac_word... " >&6; }
16555 if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
16556   $as_echo_n "(cached) " >&6
16557 else
16558   case $CHECK_TOOLSDIR_GMAKE in
16559   [\\/]* | ?:[\\/]*)
16560   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
16561   ;;
16562   *)
16563   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16564 for as_dir in $PATH
16565 do
16566   IFS=$as_save_IFS
16567   test -z "$as_dir" && as_dir=.
16568     for ac_exec_ext in '' $ac_executable_extensions; do
16569   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16570     ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
16571     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16572     break 2
16573   fi
16574 done
16575   done
16576 IFS=$as_save_IFS
16577 
16578   ;;
16579 esac
16580 fi
16581 CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
16582 if test -n "$CHECK_TOOLSDIR_GMAKE"; then
16583   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
16584 $as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
16585 else
16586   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16587 $as_echo "no" >&6; }
16588 fi
16589 
16590 
16591   test -n "$CHECK_TOOLSDIR_GMAKE" && break
16592 done
16593 
16594 
16595   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
16596   DESCRIPTION="gmake in tools-dir"
16597   if test "x$MAKE_CANDIDATE" != x; then
16598     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16599 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16600     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16601     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16602     if test "x$IS_GNU_MAKE" = x; then
16603       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16604 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16605     else
16606       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
16607       if test "x$IS_MODERN_MAKE" = x; then
16608         { $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
16609 $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;}
16610       else
16611         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16612           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16613             MAKE_EXPECTED_ENV='cygwin'
16614           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16615             MAKE_EXPECTED_ENV='msys'
16616           else
16617             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16618           fi
16619           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16620           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16621         else
16622           # Not relevant for non-Windows
16623           IS_MAKE_CORRECT_ENV=true
16624         fi
16625         if test "x$IS_MAKE_CORRECT_ENV" = x; then
16626           { $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
16627 $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;}
16628         else
16629           FOUND_MAKE=$MAKE_CANDIDATE
16630 
16631   # Only process if variable expands to non-empty
16632 
16633   if test "x$FOUND_MAKE" != x; then
16634     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16635 
16636   # First separate the path from the arguments. This will split at the first
16637   # space.
16638   complete="$FOUND_MAKE"
16639   path="${complete%% *}"
16640   tmp="$complete EOL"
16641   arguments="${tmp#* }"
16642 
16643   # Input might be given as Windows format, start by converting to
16644   # unix format.
16645   new_path=`$CYGPATH -u "$path"`
16646 
16647   # Now try to locate executable using which
16648   new_path=`$WHICH "$new_path" 2> /dev/null`
16649   # bat and cmd files are not always considered executable in cygwin causing which
16650   # to not find them
16651   if test "x$new_path" = x \
16652       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16653       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16654     new_path=`$CYGPATH -u "$path"`
16655   fi
16656   if test "x$new_path" = x; then
16657     # Oops. Which didn't find the executable.
16658     # The splitting of arguments from the executable at a space might have been incorrect,
16659     # since paths with space are more likely in Windows. Give it another try with the whole
16660     # argument.
16661     path="$complete"
16662     arguments="EOL"
16663     new_path=`$CYGPATH -u "$path"`
16664     new_path=`$WHICH "$new_path" 2> /dev/null`
16665     # bat and cmd files are not always considered executable in cygwin causing which
16666     # to not find them
16667     if test "x$new_path" = x \
16668         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16669         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16670       new_path=`$CYGPATH -u "$path"`
16671     fi
16672     if test "x$new_path" = x; then
16673       # It's still not found. Now this is an unrecoverable error.
16674       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16675 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16676       has_space=`$ECHO "$complete" | $GREP " "`
16677       if test "x$has_space" != x; then
16678         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16679 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16680       fi
16681       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16682     fi
16683   fi
16684 
16685   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
16686   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
16687   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
16688   # "foo.exe" is OK but "foo" is an error.
16689   #
16690   # This test is therefore slightly more accurate than "test -f" to check for file presence.
16691   # It is also a way to make sure we got the proper file name for the real test later on.
16692   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
16693   if test "x$test_shortpath" = x; then
16694     # Short path failed, file does not exist as specified.
16695     # Try adding .exe or .cmd
16696     if test -f "${new_path}.exe"; then
16697       input_to_shortpath="${new_path}.exe"
16698     elif test -f "${new_path}.cmd"; then
16699       input_to_shortpath="${new_path}.cmd"
16700     else
16701       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
16702 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
16703       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
16704 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
16705       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16706     fi
16707   else
16708     input_to_shortpath="$new_path"
16709   fi
16710 
16711   # Call helper function which possibly converts this using DOS-style short mode.
16712   # If so, the updated path is stored in $new_path.
16713   new_path="$input_to_shortpath"
16714 
16715   input_path="$input_to_shortpath"
16716   # Check if we need to convert this using DOS-style short mode. If the path
16717   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16718   # take no chances and rewrite it.
16719   # Note: m4 eats our [], so we need to use [ and ] instead.
16720   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
16721   if test "x$has_forbidden_chars" != x; then
16722     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16723     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
16724     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
16725     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
16726       # Going to short mode and back again did indeed matter. Since short mode is
16727       # case insensitive, let's make it lowercase to improve readability.
16728       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16729       # Now convert it back to Unix-stile (cygpath)
16730       input_path=`$CYGPATH -u "$shortmode_path"`
16731       new_path="$input_path"
16732     fi
16733   fi
16734 
16735   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
16736   if test "x$test_cygdrive_prefix" = x; then
16737     # As a simple fix, exclude /usr/bin since it's not a real path.
16738     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
16739       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
16740       # a path prefixed by /cygdrive for fixpath to work.
16741       new_path="$CYGWIN_ROOT_PATH$input_path"
16742     fi
16743   fi
16744 
16745   # remove trailing .exe if any
16746   new_path="${new_path/%.exe/}"
16747 
16748     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16749 
16750   # First separate the path from the arguments. This will split at the first
16751   # space.
16752   complete="$FOUND_MAKE"
16753   path="${complete%% *}"
16754   tmp="$complete EOL"
16755   arguments="${tmp#* }"
16756 
16757   # Input might be given as Windows format, start by converting to
16758   # unix format.
16759   new_path="$path"
16760 
16761   windows_path="$new_path"
16762   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16763     unix_path=`$CYGPATH -u "$windows_path"`
16764     new_path="$unix_path"
16765   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16766     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16767     new_path="$unix_path"
16768   fi
16769 
16770 
16771   # Now try to locate executable using which
16772   new_path=`$WHICH "$new_path" 2> /dev/null`
16773 
16774   if test "x$new_path" = x; then
16775     # Oops. Which didn't find the executable.
16776     # The splitting of arguments from the executable at a space might have been incorrect,
16777     # since paths with space are more likely in Windows. Give it another try with the whole
16778     # argument.
16779     path="$complete"
16780     arguments="EOL"
16781     new_path="$path"
16782 
16783   windows_path="$new_path"
16784   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16785     unix_path=`$CYGPATH -u "$windows_path"`
16786     new_path="$unix_path"
16787   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16788     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16789     new_path="$unix_path"
16790   fi
16791 
16792 
16793     new_path=`$WHICH "$new_path" 2> /dev/null`
16794     # bat and cmd files are not always considered executable in MSYS causing which
16795     # to not find them
16796     if test "x$new_path" = x \
16797         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
16798         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
16799       new_path="$path"
16800 
16801   windows_path="$new_path"
16802   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16803     unix_path=`$CYGPATH -u "$windows_path"`
16804     new_path="$unix_path"
16805   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16806     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16807     new_path="$unix_path"
16808   fi
16809 
16810     fi
16811 
16812     if test "x$new_path" = x; then
16813       # It's still not found. Now this is an unrecoverable error.
16814       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16815 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16816       has_space=`$ECHO "$complete" | $GREP " "`
16817       if test "x$has_space" != x; then
16818         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
16819 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
16820       fi
16821       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16822     fi
16823   fi
16824 
16825   # Now new_path has a complete unix path to the binary
16826   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
16827     # Keep paths in /bin as-is, but remove trailing .exe if any
16828     new_path="${new_path/%.exe/}"
16829     # Do not save /bin paths to all_fixpath_prefixes!
16830   else
16831     # Not in mixed or Windows style, start by that.
16832     new_path=`cmd //c echo $new_path`
16833 
16834   input_path="$new_path"
16835   # Check if we need to convert this using DOS-style short mode. If the path
16836   # contains just simple characters, use it. Otherwise (spaces, weird characters),
16837   # take no chances and rewrite it.
16838   # Note: m4 eats our [], so we need to use [ and ] instead.
16839   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
16840   if test "x$has_forbidden_chars" != x; then
16841     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
16842     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
16843   fi
16844 
16845     # Output is in $new_path
16846 
16847   windows_path="$new_path"
16848   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16849     unix_path=`$CYGPATH -u "$windows_path"`
16850     new_path="$unix_path"
16851   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16852     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
16853     new_path="$unix_path"
16854   fi
16855 
16856     # remove trailing .exe if any
16857     new_path="${new_path/%.exe/}"
16858 
16859     # Save the first 10 bytes of this path to the storage, so fixpath can work.
16860     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
16861   fi
16862 
16863     else
16864       # We're on a unix platform. Hooray! :)
16865       # First separate the path from the arguments. This will split at the first
16866       # space.
16867       complete="$FOUND_MAKE"
16868       path="${complete%% *}"
16869       tmp="$complete EOL"
16870       arguments="${tmp#* }"
16871 
16872       # Cannot rely on the command "which" here since it doesn't always work.
16873       is_absolute_path=`$ECHO "$path" | $GREP ^/`
16874       if test -z "$is_absolute_path"; then
16875         # Path to executable is not absolute. Find it.
16876         IFS_save="$IFS"
16877         IFS=:
16878         for p in $PATH; do
16879           if test -f "$p/$path" && test -x "$p/$path"; then
16880             new_path="$p/$path"
16881             break
16882           fi
16883         done
16884         IFS="$IFS_save"
16885       else
16886         # This is an absolute path, we can use it without further modifications.
16887         new_path="$path"
16888       fi
16889 
16890       if test "x$new_path" = x; then
16891         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
16892 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
16893         has_space=`$ECHO "$complete" | $GREP " "`
16894         if test "x$has_space" != x; then
16895           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
16896 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
16897         fi
16898         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
16899       fi
16900     fi
16901 
16902     # Now join together the path and the arguments once again
16903     if test "x$arguments" != xEOL; then
16904       new_complete="$new_path ${arguments% *}"
16905     else
16906       new_complete="$new_path"
16907     fi
16908 
16909     if test "x$complete" != "x$new_complete"; then
16910       FOUND_MAKE="$new_complete"
16911       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
16912 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
16913     fi
16914   fi
16915 
16916         fi
16917       fi
16918     fi
16919   fi
16920 
16921         if test "x$FOUND_MAKE" = x; then
16922           for ac_prog in make
16923 do
16924   # Extract the first word of "$ac_prog", so it can be a program name with args.
16925 set dummy $ac_prog; ac_word=$2
16926 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
16927 $as_echo_n "checking for $ac_word... " >&6; }
16928 if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
16929   $as_echo_n "(cached) " >&6
16930 else
16931   case $CHECK_TOOLSDIR_MAKE in
16932   [\\/]* | ?:[\\/]*)
16933   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
16934   ;;
16935   *)
16936   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
16937 for as_dir in $PATH
16938 do
16939   IFS=$as_save_IFS
16940   test -z "$as_dir" && as_dir=.
16941     for ac_exec_ext in '' $ac_executable_extensions; do
16942   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
16943     ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
16944     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
16945     break 2
16946   fi
16947 done
16948   done
16949 IFS=$as_save_IFS
16950 
16951   ;;
16952 esac
16953 fi
16954 CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
16955 if test -n "$CHECK_TOOLSDIR_MAKE"; then
16956   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
16957 $as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
16958 else
16959   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
16960 $as_echo "no" >&6; }
16961 fi
16962 
16963 
16964   test -n "$CHECK_TOOLSDIR_MAKE" && break
16965 done
16966 
16967 
16968   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
16969   DESCRIPTION="make in tools-dir"
16970   if test "x$MAKE_CANDIDATE" != x; then
16971     { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
16972 $as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
16973     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
16974     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
16975     if test "x$IS_GNU_MAKE" = x; then
16976       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
16977 $as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
16978     else
16979       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
16980       if test "x$IS_MODERN_MAKE" = x; then
16981         { $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
16982 $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;}
16983       else
16984         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
16985           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
16986             MAKE_EXPECTED_ENV='cygwin'
16987           elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
16988             MAKE_EXPECTED_ENV='msys'
16989           else
16990             as_fn_error $? "Unknown Windows environment" "$LINENO" 5
16991           fi
16992           MAKE_BUILT_FOR=`$MAKE_CANDIDATE --version | $GREP -i 'built for'`
16993           IS_MAKE_CORRECT_ENV=`$ECHO $MAKE_BUILT_FOR | $GREP $MAKE_EXPECTED_ENV`
16994         else
16995           # Not relevant for non-Windows
16996           IS_MAKE_CORRECT_ENV=true
16997         fi
16998         if test "x$IS_MAKE_CORRECT_ENV" = x; then
16999           { $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
17000 $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;}
17001         else
17002           FOUND_MAKE=$MAKE_CANDIDATE
17003 
17004   # Only process if variable expands to non-empty
17005 
17006   if test "x$FOUND_MAKE" != x; then
17007     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17008 
17009   # First separate the path from the arguments. This will split at the first
17010   # space.
17011   complete="$FOUND_MAKE"
17012   path="${complete%% *}"
17013   tmp="$complete EOL"
17014   arguments="${tmp#* }"
17015 
17016   # Input might be given as Windows format, start by converting to
17017   # unix format.
17018   new_path=`$CYGPATH -u "$path"`
17019 
17020   # Now try to locate executable using which
17021   new_path=`$WHICH "$new_path" 2> /dev/null`
17022   # bat and cmd files are not always considered executable in cygwin causing which
17023   # to not find them
17024   if test "x$new_path" = x \
17025       && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17026       && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17027     new_path=`$CYGPATH -u "$path"`
17028   fi
17029   if test "x$new_path" = x; then
17030     # Oops. Which didn't find the executable.
17031     # The splitting of arguments from the executable at a space might have been incorrect,
17032     # since paths with space are more likely in Windows. Give it another try with the whole
17033     # argument.
17034     path="$complete"
17035     arguments="EOL"
17036     new_path=`$CYGPATH -u "$path"`
17037     new_path=`$WHICH "$new_path" 2> /dev/null`
17038     # bat and cmd files are not always considered executable in cygwin causing which
17039     # to not find them
17040     if test "x$new_path" = x \
17041         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17042         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17043       new_path=`$CYGPATH -u "$path"`
17044     fi
17045     if test "x$new_path" = x; then
17046       # It's still not found. Now this is an unrecoverable error.
17047       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17048 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17049       has_space=`$ECHO "$complete" | $GREP " "`
17050       if test "x$has_space" != x; then
17051         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17052 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17053       fi
17054       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17055     fi
17056   fi
17057 
17058   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
17059   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
17060   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
17061   # "foo.exe" is OK but "foo" is an error.
17062   #
17063   # This test is therefore slightly more accurate than "test -f" to check for file presence.
17064   # It is also a way to make sure we got the proper file name for the real test later on.
17065   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
17066   if test "x$test_shortpath" = x; then
17067     # Short path failed, file does not exist as specified.
17068     # Try adding .exe or .cmd
17069     if test -f "${new_path}.exe"; then
17070       input_to_shortpath="${new_path}.exe"
17071     elif test -f "${new_path}.cmd"; then
17072       input_to_shortpath="${new_path}.cmd"
17073     else
17074       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
17075 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
17076       { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
17077 $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
17078       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17079     fi
17080   else
17081     input_to_shortpath="$new_path"
17082   fi
17083 
17084   # Call helper function which possibly converts this using DOS-style short mode.
17085   # If so, the updated path is stored in $new_path.
17086   new_path="$input_to_shortpath"
17087 
17088   input_path="$input_to_shortpath"
17089   # Check if we need to convert this using DOS-style short mode. If the path
17090   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17091   # take no chances and rewrite it.
17092   # Note: m4 eats our [], so we need to use [ and ] instead.
17093   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
17094   if test "x$has_forbidden_chars" != x; then
17095     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17096     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
17097     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
17098     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
17099       # Going to short mode and back again did indeed matter. Since short mode is
17100       # case insensitive, let's make it lowercase to improve readability.
17101       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17102       # Now convert it back to Unix-stile (cygpath)
17103       input_path=`$CYGPATH -u "$shortmode_path"`
17104       new_path="$input_path"
17105     fi
17106   fi
17107 
17108   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
17109   if test "x$test_cygdrive_prefix" = x; then
17110     # As a simple fix, exclude /usr/bin since it's not a real path.
17111     if test "x`$ECHO $input_to_shortpath | $GREP ^/usr/bin/`" = x; then
17112       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
17113       # a path prefixed by /cygdrive for fixpath to work.
17114       new_path="$CYGWIN_ROOT_PATH$input_path"
17115     fi
17116   fi
17117 
17118   # remove trailing .exe if any
17119   new_path="${new_path/%.exe/}"
17120 
17121     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17122 
17123   # First separate the path from the arguments. This will split at the first
17124   # space.
17125   complete="$FOUND_MAKE"
17126   path="${complete%% *}"
17127   tmp="$complete EOL"
17128   arguments="${tmp#* }"
17129 
17130   # Input might be given as Windows format, start by converting to
17131   # unix format.
17132   new_path="$path"
17133 
17134   windows_path="$new_path"
17135   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17136     unix_path=`$CYGPATH -u "$windows_path"`
17137     new_path="$unix_path"
17138   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17139     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17140     new_path="$unix_path"
17141   fi
17142 
17143 
17144   # Now try to locate executable using which
17145   new_path=`$WHICH "$new_path" 2> /dev/null`
17146 
17147   if test "x$new_path" = x; then
17148     # Oops. Which didn't find the executable.
17149     # The splitting of arguments from the executable at a space might have been incorrect,
17150     # since paths with space are more likely in Windows. Give it another try with the whole
17151     # argument.
17152     path="$complete"
17153     arguments="EOL"
17154     new_path="$path"
17155 
17156   windows_path="$new_path"
17157   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17158     unix_path=`$CYGPATH -u "$windows_path"`
17159     new_path="$unix_path"
17160   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17161     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17162     new_path="$unix_path"
17163   fi
17164 
17165 
17166     new_path=`$WHICH "$new_path" 2> /dev/null`
17167     # bat and cmd files are not always considered executable in MSYS causing which
17168     # to not find them
17169     if test "x$new_path" = x \
17170         && test "x`$ECHO \"$path\" | $GREP -i -e \"\\.bat$\" -e \"\\.cmd$\"`" != x \
17171         && test "x`$LS \"$path\" 2>/dev/null`" != x; then
17172       new_path="$path"
17173 
17174   windows_path="$new_path"
17175   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17176     unix_path=`$CYGPATH -u "$windows_path"`
17177     new_path="$unix_path"
17178   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17179     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17180     new_path="$unix_path"
17181   fi
17182 
17183     fi
17184 
17185     if test "x$new_path" = x; then
17186       # It's still not found. Now this is an unrecoverable error.
17187       { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17188 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17189       has_space=`$ECHO "$complete" | $GREP " "`
17190       if test "x$has_space" != x; then
17191         { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
17192 $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
17193       fi
17194       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17195     fi
17196   fi
17197 
17198   # Now new_path has a complete unix path to the binary
17199   if test "x`$ECHO $new_path | $GREP ^/bin/`" != x; then
17200     # Keep paths in /bin as-is, but remove trailing .exe if any
17201     new_path="${new_path/%.exe/}"
17202     # Do not save /bin paths to all_fixpath_prefixes!
17203   else
17204     # Not in mixed or Windows style, start by that.
17205     new_path=`cmd //c echo $new_path`
17206 
17207   input_path="$new_path"
17208   # Check if we need to convert this using DOS-style short mode. If the path
17209   # contains just simple characters, use it. Otherwise (spaces, weird characters),
17210   # take no chances and rewrite it.
17211   # Note: m4 eats our [], so we need to use [ and ] instead.
17212   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
17213   if test "x$has_forbidden_chars" != x; then
17214     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
17215     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
17216   fi
17217 
17218     # Output is in $new_path
17219 
17220   windows_path="$new_path"
17221   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
17222     unix_path=`$CYGPATH -u "$windows_path"`
17223     new_path="$unix_path"
17224   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
17225     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
17226     new_path="$unix_path"
17227   fi
17228 
17229     # remove trailing .exe if any
17230     new_path="${new_path/%.exe/}"
17231 
17232     # Save the first 10 bytes of this path to the storage, so fixpath can work.
17233     all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
17234   fi
17235 
17236     else
17237       # We're on a unix platform. Hooray! :)
17238       # First separate the path from the arguments. This will split at the first
17239       # space.
17240       complete="$FOUND_MAKE"
17241       path="${complete%% *}"
17242       tmp="$complete EOL"
17243       arguments="${tmp#* }"
17244 
17245       # Cannot rely on the command "which" here since it doesn't always work.
17246       is_absolute_path=`$ECHO "$path" | $GREP ^/`
17247       if test -z "$is_absolute_path"; then
17248         # Path to executable is not absolute. Find it.
17249         IFS_save="$IFS"
17250         IFS=:
17251         for p in $PATH; do
17252           if test -f "$p/$path" && test -x "$p/$path"; then
17253             new_path="$p/$path"
17254             break
17255           fi
17256         done
17257         IFS="$IFS_save"
17258       else
17259         # This is an absolute path, we can use it without further modifications.
17260         new_path="$path"
17261       fi
17262 
17263       if test "x$new_path" = x; then
17264         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
17265 $as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
17266         has_space=`$ECHO "$complete" | $GREP " "`
17267         if test "x$has_space" != x; then
17268           { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
17269 $as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
17270         fi
17271         as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
17272       fi
17273     fi
17274 
17275     # Now join together the path and the arguments once again
17276     if test "x$arguments" != xEOL; then
17277       new_complete="$new_path ${arguments% *}"
17278     else
17279       new_complete="$new_path"
17280     fi
17281 
17282     if test "x$complete" != "x$new_complete"; then
17283       FOUND_MAKE="$new_complete"
17284       { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
17285 $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
17286     fi
17287   fi
17288 
17289         fi
17290       fi
17291     fi
17292   fi
17293 
17294         fi
17295         PATH=$OLD_PATH
17296       fi
17297     fi
17298 
17299     if test "x$FOUND_MAKE" = x; then
17300       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
17301     fi
17302   fi
17303 
17304   MAKE=$FOUND_MAKE
17305 
17306   { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
17307 $as_echo "$as_me: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
17308 
17309 
17310   # Check if make supports the output sync option and if so, setup using it.
17311   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if make --output-sync is supported" >&5
17312 $as_echo_n "checking if make --output-sync is supported... " >&6; }
17313   if $MAKE --version -O > /dev/null 2>&1; then
17314     OUTPUT_SYNC_SUPPORTED=true
17315     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
17316 $as_echo "yes" >&6; }
17317     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for output-sync value" >&5
17318 $as_echo_n "checking for output-sync value... " >&6; }
17319 
17320 # Check whether --with-output-sync was given.
17321 if test "${with_output_sync+set}" = set; then :
17322   withval=$with_output_sync; OUTPUT_SYNC=$with_output_sync
17323 fi
17324 
17325     if test "x$OUTPUT_SYNC" = "x"; then
17326       OUTPUT_SYNC=none
17327     fi
17328     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_SYNC" >&5
17329 $as_echo "$OUTPUT_SYNC" >&6; }
17330     if ! $MAKE --version -O$OUTPUT_SYNC > /dev/null 2>&1; then
17331       as_fn_error $? "Make did not the support the value $OUTPUT_SYNC as output sync type." "$LINENO" 5
17332     fi
17333   else
17334     OUTPUT_SYNC_SUPPORTED=false
17335     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17336 $as_echo "no" >&6; }
17337   fi
17338 
17339 
17340 
17341 
17342 
17343 
17344   # Test if find supports -delete
17345   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
17346 $as_echo_n "checking if find supports -delete... " >&6; }
17347   FIND_DELETE="-delete"
17348 
17349   DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
17350 
17351   echo Hejsan > $DELETEDIR/TestIfFindSupportsDelete
17352 
17353   TEST_DELETE=`$FIND "$DELETEDIR" -name TestIfFindSupportsDelete $FIND_DELETE 2>&1`
17354   if test -f $DELETEDIR/TestIfFindSupportsDelete; then
17355     # No, it does not.
17356     rm $DELETEDIR/TestIfFindSupportsDelete
17357     if test "x$OPENJDK_TARGET_OS" = "xaix"; then
17358       # AIX 'find' is buggy if called with '-exec {} \+' and an empty file list
17359       FIND_DELETE="-print | xargs rm"
17360     else
17361       FIND_DELETE="-exec rm \{\} \+"
17362     fi
17363     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17364 $as_echo "no" >&6; }
17365   else
17366     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
17367 $as_echo "yes" >&6; }
17368   fi
17369   rmdir $DELETEDIR
17370 
17371 
17372 
17373   # These tools might not be installed by default,
17374   # need hint on how to install them.
17375 
17376 
17377 
17378   # Publish this variable in the help.
17379 
17380 
17381   if test "x$UNZIP" = x; then
17382     # The variable is not set by user, try to locate tool using the code snippet
17383     for ac_prog in unzip
17384 do
17385   # Extract the first word of "$ac_prog", so it can be a program name with args.
17386 set dummy $ac_prog; ac_word=$2
17387 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17388 $as_echo_n "checking for $ac_word... " >&6; }
17389 if ${ac_cv_path_UNZIP+:} false; then :
17390   $as_echo_n "(cached) " >&6
17391 else
17392   case $UNZIP in
17393   [\\/]* | ?:[\\/]*)
17394   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17395   ;;
17396   *)
17397   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17398 for as_dir in $PATH
17399 do
17400   IFS=$as_save_IFS
17401   test -z "$as_dir" && as_dir=.
17402     for ac_exec_ext in '' $ac_executable_extensions; do
17403   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17404     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17405     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17406     break 2
17407   fi
17408 done
17409   done
17410 IFS=$as_save_IFS
17411 
17412   ;;
17413 esac
17414 fi
17415 UNZIP=$ac_cv_path_UNZIP
17416 if test -n "$UNZIP"; then
17417   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17418 $as_echo "$UNZIP" >&6; }
17419 else
17420   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17421 $as_echo "no" >&6; }
17422 fi
17423 
17424 
17425   test -n "$UNZIP" && break
17426 done
17427 
17428   else
17429     # The variable is set, but is it from the command line or the environment?
17430 
17431     # Try to remove the string !UNZIP! from our list.
17432     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!UNZIP!/}
17433     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17434       # If it failed, the variable was not from the command line. Ignore it,
17435       # but warn the user (except for BASH, which is always set by the calling BASH).
17436       if test "xUNZIP" != xBASH; then
17437         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
17438 $as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
17439       fi
17440       # Try to locate tool using the code snippet
17441       for ac_prog in unzip
17442 do
17443   # Extract the first word of "$ac_prog", so it can be a program name with args.
17444 set dummy $ac_prog; ac_word=$2
17445 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17446 $as_echo_n "checking for $ac_word... " >&6; }
17447 if ${ac_cv_path_UNZIP+:} false; then :
17448   $as_echo_n "(cached) " >&6
17449 else
17450   case $UNZIP in
17451   [\\/]* | ?:[\\/]*)
17452   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17453   ;;
17454   *)
17455   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17456 for as_dir in $PATH
17457 do
17458   IFS=$as_save_IFS
17459   test -z "$as_dir" && as_dir=.
17460     for ac_exec_ext in '' $ac_executable_extensions; do
17461   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17462     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17463     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17464     break 2
17465   fi
17466 done
17467   done
17468 IFS=$as_save_IFS
17469 
17470   ;;
17471 esac
17472 fi
17473 UNZIP=$ac_cv_path_UNZIP
17474 if test -n "$UNZIP"; then
17475   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17476 $as_echo "$UNZIP" >&6; }
17477 else
17478   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17479 $as_echo "no" >&6; }
17480 fi
17481 
17482 
17483   test -n "$UNZIP" && break
17484 done
17485 
17486     else
17487       # If it succeeded, then it was overridden by the user. We will use it
17488       # for the tool.
17489 
17490       # First remove it from the list of overridden variables, so we can test
17491       # for unknown variables in the end.
17492       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17493 
17494       # Check if the provided tool contains a complete path.
17495       tool_specified="$UNZIP"
17496       tool_basename="${tool_specified##*/}"
17497       if test "x$tool_basename" = "x$tool_specified"; then
17498         # A command without a complete path is provided, search $PATH.
17499         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
17500 $as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
17501         # Extract the first word of "$tool_basename", so it can be a program name with args.
17502 set dummy $tool_basename; ac_word=$2
17503 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17504 $as_echo_n "checking for $ac_word... " >&6; }
17505 if ${ac_cv_path_UNZIP+:} false; then :
17506   $as_echo_n "(cached) " >&6
17507 else
17508   case $UNZIP in
17509   [\\/]* | ?:[\\/]*)
17510   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
17511   ;;
17512   *)
17513   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17514 for as_dir in $PATH
17515 do
17516   IFS=$as_save_IFS
17517   test -z "$as_dir" && as_dir=.
17518     for ac_exec_ext in '' $ac_executable_extensions; do
17519   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17520     ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
17521     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17522     break 2
17523   fi
17524 done
17525   done
17526 IFS=$as_save_IFS
17527 
17528   ;;
17529 esac
17530 fi
17531 UNZIP=$ac_cv_path_UNZIP
17532 if test -n "$UNZIP"; then
17533   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
17534 $as_echo "$UNZIP" >&6; }
17535 else
17536   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17537 $as_echo "no" >&6; }
17538 fi
17539 
17540 
17541         if test "x$UNZIP" = x; then
17542           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17543         fi
17544       else
17545         # Otherwise we believe it is a complete path. Use it as it is.
17546         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
17547 $as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
17548         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
17549 $as_echo_n "checking for UNZIP... " >&6; }
17550         if test ! -x "$tool_specified"; then
17551           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17552 $as_echo "not found" >&6; }
17553           as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17554         fi
17555         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17556 $as_echo "$tool_specified" >&6; }
17557       fi
17558     fi
17559   fi
17560 
17561 
17562 
17563   if test "x$UNZIP" = x; then
17564     as_fn_error $? "Could not find required tool for UNZIP" "$LINENO" 5
17565   fi
17566 
17567 
17568 
17569 
17570 
17571   # Publish this variable in the help.
17572 
17573 
17574   if test "x$ZIP" = x; then
17575     # The variable is not set by user, try to locate tool using the code snippet
17576     for ac_prog in zip
17577 do
17578   # Extract the first word of "$ac_prog", so it can be a program name with args.
17579 set dummy $ac_prog; ac_word=$2
17580 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17581 $as_echo_n "checking for $ac_word... " >&6; }
17582 if ${ac_cv_path_ZIP+:} false; then :
17583   $as_echo_n "(cached) " >&6
17584 else
17585   case $ZIP in
17586   [\\/]* | ?:[\\/]*)
17587   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17588   ;;
17589   *)
17590   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17591 for as_dir in $PATH
17592 do
17593   IFS=$as_save_IFS
17594   test -z "$as_dir" && as_dir=.
17595     for ac_exec_ext in '' $ac_executable_extensions; do
17596   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17597     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17598     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17599     break 2
17600   fi
17601 done
17602   done
17603 IFS=$as_save_IFS
17604 
17605   ;;
17606 esac
17607 fi
17608 ZIP=$ac_cv_path_ZIP
17609 if test -n "$ZIP"; then
17610   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17611 $as_echo "$ZIP" >&6; }
17612 else
17613   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17614 $as_echo "no" >&6; }
17615 fi
17616 
17617 
17618   test -n "$ZIP" && break
17619 done
17620 
17621   else
17622     # The variable is set, but is it from the command line or the environment?
17623 
17624     # Try to remove the string !ZIP! from our list.
17625     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!ZIP!/}
17626     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17627       # If it failed, the variable was not from the command line. Ignore it,
17628       # but warn the user (except for BASH, which is always set by the calling BASH).
17629       if test "xZIP" != xBASH; then
17630         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
17631 $as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
17632       fi
17633       # Try to locate tool using the code snippet
17634       for ac_prog in zip
17635 do
17636   # Extract the first word of "$ac_prog", so it can be a program name with args.
17637 set dummy $ac_prog; ac_word=$2
17638 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17639 $as_echo_n "checking for $ac_word... " >&6; }
17640 if ${ac_cv_path_ZIP+:} false; then :
17641   $as_echo_n "(cached) " >&6
17642 else
17643   case $ZIP in
17644   [\\/]* | ?:[\\/]*)
17645   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17646   ;;
17647   *)
17648   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17649 for as_dir in $PATH
17650 do
17651   IFS=$as_save_IFS
17652   test -z "$as_dir" && as_dir=.
17653     for ac_exec_ext in '' $ac_executable_extensions; do
17654   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17655     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17656     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17657     break 2
17658   fi
17659 done
17660   done
17661 IFS=$as_save_IFS
17662 
17663   ;;
17664 esac
17665 fi
17666 ZIP=$ac_cv_path_ZIP
17667 if test -n "$ZIP"; then
17668   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17669 $as_echo "$ZIP" >&6; }
17670 else
17671   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17672 $as_echo "no" >&6; }
17673 fi
17674 
17675 
17676   test -n "$ZIP" && break
17677 done
17678 
17679     else
17680       # If it succeeded, then it was overridden by the user. We will use it
17681       # for the tool.
17682 
17683       # First remove it from the list of overridden variables, so we can test
17684       # for unknown variables in the end.
17685       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17686 
17687       # Check if the provided tool contains a complete path.
17688       tool_specified="$ZIP"
17689       tool_basename="${tool_specified##*/}"
17690       if test "x$tool_basename" = "x$tool_specified"; then
17691         # A command without a complete path is provided, search $PATH.
17692         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
17693 $as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
17694         # Extract the first word of "$tool_basename", so it can be a program name with args.
17695 set dummy $tool_basename; ac_word=$2
17696 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17697 $as_echo_n "checking for $ac_word... " >&6; }
17698 if ${ac_cv_path_ZIP+:} false; then :
17699   $as_echo_n "(cached) " >&6
17700 else
17701   case $ZIP in
17702   [\\/]* | ?:[\\/]*)
17703   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
17704   ;;
17705   *)
17706   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17707 for as_dir in $PATH
17708 do
17709   IFS=$as_save_IFS
17710   test -z "$as_dir" && as_dir=.
17711     for ac_exec_ext in '' $ac_executable_extensions; do
17712   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17713     ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
17714     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17715     break 2
17716   fi
17717 done
17718   done
17719 IFS=$as_save_IFS
17720 
17721   ;;
17722 esac
17723 fi
17724 ZIP=$ac_cv_path_ZIP
17725 if test -n "$ZIP"; then
17726   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
17727 $as_echo "$ZIP" >&6; }
17728 else
17729   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17730 $as_echo "no" >&6; }
17731 fi
17732 
17733 
17734         if test "x$ZIP" = x; then
17735           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17736         fi
17737       else
17738         # Otherwise we believe it is a complete path. Use it as it is.
17739         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
17740 $as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
17741         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
17742 $as_echo_n "checking for ZIP... " >&6; }
17743         if test ! -x "$tool_specified"; then
17744           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17745 $as_echo "not found" >&6; }
17746           as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
17747         fi
17748         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17749 $as_echo "$tool_specified" >&6; }
17750       fi
17751     fi
17752   fi
17753 
17754 
17755 
17756   if test "x$ZIP" = x; then
17757     as_fn_error $? "Could not find required tool for ZIP" "$LINENO" 5
17758   fi
17759 
17760 
17761 
17762   # Non-required basic tools
17763 
17764 
17765 
17766   # Publish this variable in the help.
17767 
17768 
17769   if test "x$LDD" = x; then
17770     # The variable is not set by user, try to locate tool using the code snippet
17771     for ac_prog in ldd
17772 do
17773   # Extract the first word of "$ac_prog", so it can be a program name with args.
17774 set dummy $ac_prog; ac_word=$2
17775 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17776 $as_echo_n "checking for $ac_word... " >&6; }
17777 if ${ac_cv_path_LDD+:} false; then :
17778   $as_echo_n "(cached) " >&6
17779 else
17780   case $LDD in
17781   [\\/]* | ?:[\\/]*)
17782   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17783   ;;
17784   *)
17785   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17786 for as_dir in $PATH
17787 do
17788   IFS=$as_save_IFS
17789   test -z "$as_dir" && as_dir=.
17790     for ac_exec_ext in '' $ac_executable_extensions; do
17791   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17792     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17793     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17794     break 2
17795   fi
17796 done
17797   done
17798 IFS=$as_save_IFS
17799 
17800   ;;
17801 esac
17802 fi
17803 LDD=$ac_cv_path_LDD
17804 if test -n "$LDD"; then
17805   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17806 $as_echo "$LDD" >&6; }
17807 else
17808   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17809 $as_echo "no" >&6; }
17810 fi
17811 
17812 
17813   test -n "$LDD" && break
17814 done
17815 
17816   else
17817     # The variable is set, but is it from the command line or the environment?
17818 
17819     # Try to remove the string !LDD! from our list.
17820     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!LDD!/}
17821     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
17822       # If it failed, the variable was not from the command line. Ignore it,
17823       # but warn the user (except for BASH, which is always set by the calling BASH).
17824       if test "xLDD" != xBASH; then
17825         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
17826 $as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
17827       fi
17828       # Try to locate tool using the code snippet
17829       for ac_prog in ldd
17830 do
17831   # Extract the first word of "$ac_prog", so it can be a program name with args.
17832 set dummy $ac_prog; ac_word=$2
17833 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17834 $as_echo_n "checking for $ac_word... " >&6; }
17835 if ${ac_cv_path_LDD+:} false; then :
17836   $as_echo_n "(cached) " >&6
17837 else
17838   case $LDD in
17839   [\\/]* | ?:[\\/]*)
17840   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17841   ;;
17842   *)
17843   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17844 for as_dir in $PATH
17845 do
17846   IFS=$as_save_IFS
17847   test -z "$as_dir" && as_dir=.
17848     for ac_exec_ext in '' $ac_executable_extensions; do
17849   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17850     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17851     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17852     break 2
17853   fi
17854 done
17855   done
17856 IFS=$as_save_IFS
17857 
17858   ;;
17859 esac
17860 fi
17861 LDD=$ac_cv_path_LDD
17862 if test -n "$LDD"; then
17863   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17864 $as_echo "$LDD" >&6; }
17865 else
17866   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17867 $as_echo "no" >&6; }
17868 fi
17869 
17870 
17871   test -n "$LDD" && break
17872 done
17873 
17874     else
17875       # If it succeeded, then it was overridden by the user. We will use it
17876       # for the tool.
17877 
17878       # First remove it from the list of overridden variables, so we can test
17879       # for unknown variables in the end.
17880       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
17881 
17882       # Check if the provided tool contains a complete path.
17883       tool_specified="$LDD"
17884       tool_basename="${tool_specified##*/}"
17885       if test "x$tool_basename" = "x$tool_specified"; then
17886         # A command without a complete path is provided, search $PATH.
17887         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
17888 $as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
17889         # Extract the first word of "$tool_basename", so it can be a program name with args.
17890 set dummy $tool_basename; ac_word=$2
17891 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17892 $as_echo_n "checking for $ac_word... " >&6; }
17893 if ${ac_cv_path_LDD+:} false; then :
17894   $as_echo_n "(cached) " >&6
17895 else
17896   case $LDD in
17897   [\\/]* | ?:[\\/]*)
17898   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
17899   ;;
17900   *)
17901   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17902 for as_dir in $PATH
17903 do
17904   IFS=$as_save_IFS
17905   test -z "$as_dir" && as_dir=.
17906     for ac_exec_ext in '' $ac_executable_extensions; do
17907   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17908     ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
17909     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17910     break 2
17911   fi
17912 done
17913   done
17914 IFS=$as_save_IFS
17915 
17916   ;;
17917 esac
17918 fi
17919 LDD=$ac_cv_path_LDD
17920 if test -n "$LDD"; then
17921   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
17922 $as_echo "$LDD" >&6; }
17923 else
17924   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17925 $as_echo "no" >&6; }
17926 fi
17927 
17928 
17929         if test "x$LDD" = x; then
17930           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
17931         fi
17932       else
17933         # Otherwise we believe it is a complete path. Use it as it is.
17934         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
17935 $as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
17936         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
17937 $as_echo_n "checking for LDD... " >&6; }
17938         if test ! -x "$tool_specified"; then
17939           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
17940 $as_echo "not found" >&6; }
17941           as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
17942         fi
17943         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
17944 $as_echo "$tool_specified" >&6; }
17945       fi
17946     fi
17947   fi
17948 
17949 
17950   if test "x$LDD" = "x"; then
17951     # List shared lib dependencies is used for
17952     # debug output and checking for forbidden dependencies.
17953     # We can build without it.
17954     LDD="true"
17955   fi
17956 
17957 
17958   # Publish this variable in the help.
17959 
17960 
17961   if test "x$OTOOL" = x; then
17962     # The variable is not set by user, try to locate tool using the code snippet
17963     for ac_prog in otool
17964 do
17965   # Extract the first word of "$ac_prog", so it can be a program name with args.
17966 set dummy $ac_prog; ac_word=$2
17967 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
17968 $as_echo_n "checking for $ac_word... " >&6; }
17969 if ${ac_cv_path_OTOOL+:} false; then :
17970   $as_echo_n "(cached) " >&6
17971 else
17972   case $OTOOL in
17973   [\\/]* | ?:[\\/]*)
17974   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
17975   ;;
17976   *)
17977   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
17978 for as_dir in $PATH
17979 do
17980   IFS=$as_save_IFS
17981   test -z "$as_dir" && as_dir=.
17982     for ac_exec_ext in '' $ac_executable_extensions; do
17983   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
17984     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
17985     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
17986     break 2
17987   fi
17988 done
17989   done
17990 IFS=$as_save_IFS
17991 
17992   ;;
17993 esac
17994 fi
17995 OTOOL=$ac_cv_path_OTOOL
17996 if test -n "$OTOOL"; then
17997   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
17998 $as_echo "$OTOOL" >&6; }
17999 else
18000   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18001 $as_echo "no" >&6; }
18002 fi
18003 
18004 
18005   test -n "$OTOOL" && break
18006 done
18007 
18008   else
18009     # The variable is set, but is it from the command line or the environment?
18010 
18011     # Try to remove the string !OTOOL! from our list.
18012     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!OTOOL!/}
18013     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18014       # If it failed, the variable was not from the command line. Ignore it,
18015       # but warn the user (except for BASH, which is always set by the calling BASH).
18016       if test "xOTOOL" != xBASH; then
18017         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&5
18018 $as_echo "$as_me: WARNING: Ignoring value of OTOOL from the environment. Use command line variables instead." >&2;}
18019       fi
18020       # Try to locate tool using the code snippet
18021       for ac_prog in otool
18022 do
18023   # Extract the first word of "$ac_prog", so it can be a program name with args.
18024 set dummy $ac_prog; ac_word=$2
18025 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18026 $as_echo_n "checking for $ac_word... " >&6; }
18027 if ${ac_cv_path_OTOOL+:} false; then :
18028   $as_echo_n "(cached) " >&6
18029 else
18030   case $OTOOL in
18031   [\\/]* | ?:[\\/]*)
18032   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
18033   ;;
18034   *)
18035   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18036 for as_dir in $PATH
18037 do
18038   IFS=$as_save_IFS
18039   test -z "$as_dir" && as_dir=.
18040     for ac_exec_ext in '' $ac_executable_extensions; do
18041   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18042     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
18043     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18044     break 2
18045   fi
18046 done
18047   done
18048 IFS=$as_save_IFS
18049 
18050   ;;
18051 esac
18052 fi
18053 OTOOL=$ac_cv_path_OTOOL
18054 if test -n "$OTOOL"; then
18055   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
18056 $as_echo "$OTOOL" >&6; }
18057 else
18058   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18059 $as_echo "no" >&6; }
18060 fi
18061 
18062 
18063   test -n "$OTOOL" && break
18064 done
18065 
18066     else
18067       # If it succeeded, then it was overridden by the user. We will use it
18068       # for the tool.
18069 
18070       # First remove it from the list of overridden variables, so we can test
18071       # for unknown variables in the end.
18072       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18073 
18074       # Check if the provided tool contains a complete path.
18075       tool_specified="$OTOOL"
18076       tool_basename="${tool_specified##*/}"
18077       if test "x$tool_basename" = "x$tool_specified"; then
18078         # A command without a complete path is provided, search $PATH.
18079         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OTOOL=$tool_basename" >&5
18080 $as_echo "$as_me: Will search for user supplied tool OTOOL=$tool_basename" >&6;}
18081         # Extract the first word of "$tool_basename", so it can be a program name with args.
18082 set dummy $tool_basename; ac_word=$2
18083 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18084 $as_echo_n "checking for $ac_word... " >&6; }
18085 if ${ac_cv_path_OTOOL+:} false; then :
18086   $as_echo_n "(cached) " >&6
18087 else
18088   case $OTOOL in
18089   [\\/]* | ?:[\\/]*)
18090   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
18091   ;;
18092   *)
18093   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18094 for as_dir in $PATH
18095 do
18096   IFS=$as_save_IFS
18097   test -z "$as_dir" && as_dir=.
18098     for ac_exec_ext in '' $ac_executable_extensions; do
18099   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18100     ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
18101     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18102     break 2
18103   fi
18104 done
18105   done
18106 IFS=$as_save_IFS
18107 
18108   ;;
18109 esac
18110 fi
18111 OTOOL=$ac_cv_path_OTOOL
18112 if test -n "$OTOOL"; then
18113   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
18114 $as_echo "$OTOOL" >&6; }
18115 else
18116   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18117 $as_echo "no" >&6; }
18118 fi
18119 
18120 
18121         if test "x$OTOOL" = x; then
18122           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18123         fi
18124       else
18125         # Otherwise we believe it is a complete path. Use it as it is.
18126         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OTOOL=$tool_specified" >&5
18127 $as_echo "$as_me: Will use user supplied tool OTOOL=$tool_specified" >&6;}
18128         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OTOOL" >&5
18129 $as_echo_n "checking for OTOOL... " >&6; }
18130         if test ! -x "$tool_specified"; then
18131           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18132 $as_echo "not found" >&6; }
18133           as_fn_error $? "User supplied tool OTOOL=$tool_specified does not exist or is not executable" "$LINENO" 5
18134         fi
18135         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18136 $as_echo "$tool_specified" >&6; }
18137       fi
18138     fi
18139   fi
18140 
18141 
18142   if test "x$OTOOL" = "x"; then
18143     OTOOL="true"
18144   fi
18145 
18146 
18147   # Publish this variable in the help.
18148 
18149 
18150   if test "x$READELF" = x; then
18151     # The variable is not set by user, try to locate tool using the code snippet
18152     for ac_prog in greadelf readelf
18153 do
18154   # Extract the first word of "$ac_prog", so it can be a program name with args.
18155 set dummy $ac_prog; ac_word=$2
18156 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18157 $as_echo_n "checking for $ac_word... " >&6; }
18158 if ${ac_cv_path_READELF+:} false; then :
18159   $as_echo_n "(cached) " >&6
18160 else
18161   case $READELF in
18162   [\\/]* | ?:[\\/]*)
18163   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
18164   ;;
18165   *)
18166   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18167 for as_dir in $PATH
18168 do
18169   IFS=$as_save_IFS
18170   test -z "$as_dir" && as_dir=.
18171     for ac_exec_ext in '' $ac_executable_extensions; do
18172   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18173     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
18174     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18175     break 2
18176   fi
18177 done
18178   done
18179 IFS=$as_save_IFS
18180 
18181   ;;
18182 esac
18183 fi
18184 READELF=$ac_cv_path_READELF
18185 if test -n "$READELF"; then
18186   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
18187 $as_echo "$READELF" >&6; }
18188 else
18189   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18190 $as_echo "no" >&6; }
18191 fi
18192 
18193 
18194   test -n "$READELF" && break
18195 done
18196 
18197   else
18198     # The variable is set, but is it from the command line or the environment?
18199 
18200     # Try to remove the string !READELF! from our list.
18201     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!READELF!/}
18202     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18203       # If it failed, the variable was not from the command line. Ignore it,
18204       # but warn the user (except for BASH, which is always set by the calling BASH).
18205       if test "xREADELF" != xBASH; then
18206         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
18207 $as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
18208       fi
18209       # Try to locate tool using the code snippet
18210       for ac_prog in greadelf readelf
18211 do
18212   # Extract the first word of "$ac_prog", so it can be a program name with args.
18213 set dummy $ac_prog; ac_word=$2
18214 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18215 $as_echo_n "checking for $ac_word... " >&6; }
18216 if ${ac_cv_path_READELF+:} false; then :
18217   $as_echo_n "(cached) " >&6
18218 else
18219   case $READELF in
18220   [\\/]* | ?:[\\/]*)
18221   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
18222   ;;
18223   *)
18224   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18225 for as_dir in $PATH
18226 do
18227   IFS=$as_save_IFS
18228   test -z "$as_dir" && as_dir=.
18229     for ac_exec_ext in '' $ac_executable_extensions; do
18230   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18231     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
18232     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18233     break 2
18234   fi
18235 done
18236   done
18237 IFS=$as_save_IFS
18238 
18239   ;;
18240 esac
18241 fi
18242 READELF=$ac_cv_path_READELF
18243 if test -n "$READELF"; then
18244   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
18245 $as_echo "$READELF" >&6; }
18246 else
18247   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18248 $as_echo "no" >&6; }
18249 fi
18250 
18251 
18252   test -n "$READELF" && break
18253 done
18254 
18255     else
18256       # If it succeeded, then it was overridden by the user. We will use it
18257       # for the tool.
18258 
18259       # First remove it from the list of overridden variables, so we can test
18260       # for unknown variables in the end.
18261       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18262 
18263       # Check if the provided tool contains a complete path.
18264       tool_specified="$READELF"
18265       tool_basename="${tool_specified##*/}"
18266       if test "x$tool_basename" = "x$tool_specified"; then
18267         # A command without a complete path is provided, search $PATH.
18268         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
18269 $as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
18270         # Extract the first word of "$tool_basename", so it can be a program name with args.
18271 set dummy $tool_basename; ac_word=$2
18272 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18273 $as_echo_n "checking for $ac_word... " >&6; }
18274 if ${ac_cv_path_READELF+:} false; then :
18275   $as_echo_n "(cached) " >&6
18276 else
18277   case $READELF in
18278   [\\/]* | ?:[\\/]*)
18279   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
18280   ;;
18281   *)
18282   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18283 for as_dir in $PATH
18284 do
18285   IFS=$as_save_IFS
18286   test -z "$as_dir" && as_dir=.
18287     for ac_exec_ext in '' $ac_executable_extensions; do
18288   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18289     ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
18290     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18291     break 2
18292   fi
18293 done
18294   done
18295 IFS=$as_save_IFS
18296 
18297   ;;
18298 esac
18299 fi
18300 READELF=$ac_cv_path_READELF
18301 if test -n "$READELF"; then
18302   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
18303 $as_echo "$READELF" >&6; }
18304 else
18305   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18306 $as_echo "no" >&6; }
18307 fi
18308 
18309 
18310         if test "x$READELF" = x; then
18311           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18312         fi
18313       else
18314         # Otherwise we believe it is a complete path. Use it as it is.
18315         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
18316 $as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
18317         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
18318 $as_echo_n "checking for READELF... " >&6; }
18319         if test ! -x "$tool_specified"; then
18320           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18321 $as_echo "not found" >&6; }
18322           as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
18323         fi
18324         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18325 $as_echo "$tool_specified" >&6; }
18326       fi
18327     fi
18328   fi
18329 
18330 
18331 
18332 
18333   # Publish this variable in the help.
18334 
18335 
18336   if test "x$HG" = x; then
18337     # The variable is not set by user, try to locate tool using the code snippet
18338     for ac_prog in hg
18339 do
18340   # Extract the first word of "$ac_prog", so it can be a program name with args.
18341 set dummy $ac_prog; ac_word=$2
18342 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18343 $as_echo_n "checking for $ac_word... " >&6; }
18344 if ${ac_cv_path_HG+:} false; then :
18345   $as_echo_n "(cached) " >&6
18346 else
18347   case $HG in
18348   [\\/]* | ?:[\\/]*)
18349   ac_cv_path_HG="$HG" # Let the user override the test with a path.
18350   ;;
18351   *)
18352   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18353 for as_dir in $PATH
18354 do
18355   IFS=$as_save_IFS
18356   test -z "$as_dir" && as_dir=.
18357     for ac_exec_ext in '' $ac_executable_extensions; do
18358   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18359     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18360     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18361     break 2
18362   fi
18363 done
18364   done
18365 IFS=$as_save_IFS
18366 
18367   ;;
18368 esac
18369 fi
18370 HG=$ac_cv_path_HG
18371 if test -n "$HG"; then
18372   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18373 $as_echo "$HG" >&6; }
18374 else
18375   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18376 $as_echo "no" >&6; }
18377 fi
18378 
18379 
18380   test -n "$HG" && break
18381 done
18382 
18383   else
18384     # The variable is set, but is it from the command line or the environment?
18385 
18386     # Try to remove the string !HG! from our list.
18387     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!HG!/}
18388     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18389       # If it failed, the variable was not from the command line. Ignore it,
18390       # but warn the user (except for BASH, which is always set by the calling BASH).
18391       if test "xHG" != xBASH; then
18392         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
18393 $as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
18394       fi
18395       # Try to locate tool using the code snippet
18396       for ac_prog in hg
18397 do
18398   # Extract the first word of "$ac_prog", so it can be a program name with args.
18399 set dummy $ac_prog; ac_word=$2
18400 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18401 $as_echo_n "checking for $ac_word... " >&6; }
18402 if ${ac_cv_path_HG+:} false; then :
18403   $as_echo_n "(cached) " >&6
18404 else
18405   case $HG in
18406   [\\/]* | ?:[\\/]*)
18407   ac_cv_path_HG="$HG" # Let the user override the test with a path.
18408   ;;
18409   *)
18410   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18411 for as_dir in $PATH
18412 do
18413   IFS=$as_save_IFS
18414   test -z "$as_dir" && as_dir=.
18415     for ac_exec_ext in '' $ac_executable_extensions; do
18416   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18417     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18418     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18419     break 2
18420   fi
18421 done
18422   done
18423 IFS=$as_save_IFS
18424 
18425   ;;
18426 esac
18427 fi
18428 HG=$ac_cv_path_HG
18429 if test -n "$HG"; then
18430   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18431 $as_echo "$HG" >&6; }
18432 else
18433   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18434 $as_echo "no" >&6; }
18435 fi
18436 
18437 
18438   test -n "$HG" && break
18439 done
18440 
18441     else
18442       # If it succeeded, then it was overridden by the user. We will use it
18443       # for the tool.
18444 
18445       # First remove it from the list of overridden variables, so we can test
18446       # for unknown variables in the end.
18447       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18448 
18449       # Check if the provided tool contains a complete path.
18450       tool_specified="$HG"
18451       tool_basename="${tool_specified##*/}"
18452       if test "x$tool_basename" = "x$tool_specified"; then
18453         # A command without a complete path is provided, search $PATH.
18454         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
18455 $as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
18456         # Extract the first word of "$tool_basename", so it can be a program name with args.
18457 set dummy $tool_basename; ac_word=$2
18458 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18459 $as_echo_n "checking for $ac_word... " >&6; }
18460 if ${ac_cv_path_HG+:} false; then :
18461   $as_echo_n "(cached) " >&6
18462 else
18463   case $HG in
18464   [\\/]* | ?:[\\/]*)
18465   ac_cv_path_HG="$HG" # Let the user override the test with a path.
18466   ;;
18467   *)
18468   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18469 for as_dir in $PATH
18470 do
18471   IFS=$as_save_IFS
18472   test -z "$as_dir" && as_dir=.
18473     for ac_exec_ext in '' $ac_executable_extensions; do
18474   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18475     ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
18476     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18477     break 2
18478   fi
18479 done
18480   done
18481 IFS=$as_save_IFS
18482 
18483   ;;
18484 esac
18485 fi
18486 HG=$ac_cv_path_HG
18487 if test -n "$HG"; then
18488   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
18489 $as_echo "$HG" >&6; }
18490 else
18491   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18492 $as_echo "no" >&6; }
18493 fi
18494 
18495 
18496         if test "x$HG" = x; then
18497           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18498         fi
18499       else
18500         # Otherwise we believe it is a complete path. Use it as it is.
18501         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
18502 $as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
18503         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
18504 $as_echo_n "checking for HG... " >&6; }
18505         if test ! -x "$tool_specified"; then
18506           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18507 $as_echo "not found" >&6; }
18508           as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
18509         fi
18510         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18511 $as_echo "$tool_specified" >&6; }
18512       fi
18513     fi
18514   fi
18515 
18516 
18517 
18518 
18519   # Publish this variable in the help.
18520 
18521 
18522   if test "x$STAT" = x; then
18523     # The variable is not set by user, try to locate tool using the code snippet
18524     for ac_prog in stat
18525 do
18526   # Extract the first word of "$ac_prog", so it can be a program name with args.
18527 set dummy $ac_prog; ac_word=$2
18528 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18529 $as_echo_n "checking for $ac_word... " >&6; }
18530 if ${ac_cv_path_STAT+:} false; then :
18531   $as_echo_n "(cached) " >&6
18532 else
18533   case $STAT in
18534   [\\/]* | ?:[\\/]*)
18535   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18536   ;;
18537   *)
18538   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18539 for as_dir in $PATH
18540 do
18541   IFS=$as_save_IFS
18542   test -z "$as_dir" && as_dir=.
18543     for ac_exec_ext in '' $ac_executable_extensions; do
18544   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18545     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18546     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18547     break 2
18548   fi
18549 done
18550   done
18551 IFS=$as_save_IFS
18552 
18553   ;;
18554 esac
18555 fi
18556 STAT=$ac_cv_path_STAT
18557 if test -n "$STAT"; then
18558   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18559 $as_echo "$STAT" >&6; }
18560 else
18561   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18562 $as_echo "no" >&6; }
18563 fi
18564 
18565 
18566   test -n "$STAT" && break
18567 done
18568 
18569   else
18570     # The variable is set, but is it from the command line or the environment?
18571 
18572     # Try to remove the string !STAT! from our list.
18573     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!STAT!/}
18574     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18575       # If it failed, the variable was not from the command line. Ignore it,
18576       # but warn the user (except for BASH, which is always set by the calling BASH).
18577       if test "xSTAT" != xBASH; then
18578         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
18579 $as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
18580       fi
18581       # Try to locate tool using the code snippet
18582       for ac_prog in stat
18583 do
18584   # Extract the first word of "$ac_prog", so it can be a program name with args.
18585 set dummy $ac_prog; ac_word=$2
18586 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18587 $as_echo_n "checking for $ac_word... " >&6; }
18588 if ${ac_cv_path_STAT+:} false; then :
18589   $as_echo_n "(cached) " >&6
18590 else
18591   case $STAT in
18592   [\\/]* | ?:[\\/]*)
18593   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18594   ;;
18595   *)
18596   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18597 for as_dir in $PATH
18598 do
18599   IFS=$as_save_IFS
18600   test -z "$as_dir" && as_dir=.
18601     for ac_exec_ext in '' $ac_executable_extensions; do
18602   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18603     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18604     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18605     break 2
18606   fi
18607 done
18608   done
18609 IFS=$as_save_IFS
18610 
18611   ;;
18612 esac
18613 fi
18614 STAT=$ac_cv_path_STAT
18615 if test -n "$STAT"; then
18616   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18617 $as_echo "$STAT" >&6; }
18618 else
18619   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18620 $as_echo "no" >&6; }
18621 fi
18622 
18623 
18624   test -n "$STAT" && break
18625 done
18626 
18627     else
18628       # If it succeeded, then it was overridden by the user. We will use it
18629       # for the tool.
18630 
18631       # First remove it from the list of overridden variables, so we can test
18632       # for unknown variables in the end.
18633       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18634 
18635       # Check if the provided tool contains a complete path.
18636       tool_specified="$STAT"
18637       tool_basename="${tool_specified##*/}"
18638       if test "x$tool_basename" = "x$tool_specified"; then
18639         # A command without a complete path is provided, search $PATH.
18640         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
18641 $as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
18642         # Extract the first word of "$tool_basename", so it can be a program name with args.
18643 set dummy $tool_basename; ac_word=$2
18644 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18645 $as_echo_n "checking for $ac_word... " >&6; }
18646 if ${ac_cv_path_STAT+:} false; then :
18647   $as_echo_n "(cached) " >&6
18648 else
18649   case $STAT in
18650   [\\/]* | ?:[\\/]*)
18651   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
18652   ;;
18653   *)
18654   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18655 for as_dir in $PATH
18656 do
18657   IFS=$as_save_IFS
18658   test -z "$as_dir" && as_dir=.
18659     for ac_exec_ext in '' $ac_executable_extensions; do
18660   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18661     ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
18662     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18663     break 2
18664   fi
18665 done
18666   done
18667 IFS=$as_save_IFS
18668 
18669   ;;
18670 esac
18671 fi
18672 STAT=$ac_cv_path_STAT
18673 if test -n "$STAT"; then
18674   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
18675 $as_echo "$STAT" >&6; }
18676 else
18677   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18678 $as_echo "no" >&6; }
18679 fi
18680 
18681 
18682         if test "x$STAT" = x; then
18683           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18684         fi
18685       else
18686         # Otherwise we believe it is a complete path. Use it as it is.
18687         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
18688 $as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
18689         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
18690 $as_echo_n "checking for STAT... " >&6; }
18691         if test ! -x "$tool_specified"; then
18692           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18693 $as_echo "not found" >&6; }
18694           as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
18695         fi
18696         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18697 $as_echo "$tool_specified" >&6; }
18698       fi
18699     fi
18700   fi
18701 
18702 
18703 
18704 
18705   # Publish this variable in the help.
18706 
18707 
18708   if test "x$TIME" = x; then
18709     # The variable is not set by user, try to locate tool using the code snippet
18710     for ac_prog in time
18711 do
18712   # Extract the first word of "$ac_prog", so it can be a program name with args.
18713 set dummy $ac_prog; ac_word=$2
18714 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18715 $as_echo_n "checking for $ac_word... " >&6; }
18716 if ${ac_cv_path_TIME+:} false; then :
18717   $as_echo_n "(cached) " >&6
18718 else
18719   case $TIME in
18720   [\\/]* | ?:[\\/]*)
18721   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18722   ;;
18723   *)
18724   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18725 for as_dir in $PATH
18726 do
18727   IFS=$as_save_IFS
18728   test -z "$as_dir" && as_dir=.
18729     for ac_exec_ext in '' $ac_executable_extensions; do
18730   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18731     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18732     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18733     break 2
18734   fi
18735 done
18736   done
18737 IFS=$as_save_IFS
18738 
18739   ;;
18740 esac
18741 fi
18742 TIME=$ac_cv_path_TIME
18743 if test -n "$TIME"; then
18744   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18745 $as_echo "$TIME" >&6; }
18746 else
18747   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18748 $as_echo "no" >&6; }
18749 fi
18750 
18751 
18752   test -n "$TIME" && break
18753 done
18754 
18755   else
18756     # The variable is set, but is it from the command line or the environment?
18757 
18758     # Try to remove the string !TIME! from our list.
18759     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!TIME!/}
18760     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18761       # If it failed, the variable was not from the command line. Ignore it,
18762       # but warn the user (except for BASH, which is always set by the calling BASH).
18763       if test "xTIME" != xBASH; then
18764         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
18765 $as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
18766       fi
18767       # Try to locate tool using the code snippet
18768       for ac_prog in time
18769 do
18770   # Extract the first word of "$ac_prog", so it can be a program name with args.
18771 set dummy $ac_prog; ac_word=$2
18772 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18773 $as_echo_n "checking for $ac_word... " >&6; }
18774 if ${ac_cv_path_TIME+:} false; then :
18775   $as_echo_n "(cached) " >&6
18776 else
18777   case $TIME in
18778   [\\/]* | ?:[\\/]*)
18779   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18780   ;;
18781   *)
18782   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18783 for as_dir in $PATH
18784 do
18785   IFS=$as_save_IFS
18786   test -z "$as_dir" && as_dir=.
18787     for ac_exec_ext in '' $ac_executable_extensions; do
18788   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18789     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18790     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18791     break 2
18792   fi
18793 done
18794   done
18795 IFS=$as_save_IFS
18796 
18797   ;;
18798 esac
18799 fi
18800 TIME=$ac_cv_path_TIME
18801 if test -n "$TIME"; then
18802   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18803 $as_echo "$TIME" >&6; }
18804 else
18805   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18806 $as_echo "no" >&6; }
18807 fi
18808 
18809 
18810   test -n "$TIME" && break
18811 done
18812 
18813     else
18814       # If it succeeded, then it was overridden by the user. We will use it
18815       # for the tool.
18816 
18817       # First remove it from the list of overridden variables, so we can test
18818       # for unknown variables in the end.
18819       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
18820 
18821       # Check if the provided tool contains a complete path.
18822       tool_specified="$TIME"
18823       tool_basename="${tool_specified##*/}"
18824       if test "x$tool_basename" = "x$tool_specified"; then
18825         # A command without a complete path is provided, search $PATH.
18826         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
18827 $as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
18828         # Extract the first word of "$tool_basename", so it can be a program name with args.
18829 set dummy $tool_basename; ac_word=$2
18830 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18831 $as_echo_n "checking for $ac_word... " >&6; }
18832 if ${ac_cv_path_TIME+:} false; then :
18833   $as_echo_n "(cached) " >&6
18834 else
18835   case $TIME in
18836   [\\/]* | ?:[\\/]*)
18837   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
18838   ;;
18839   *)
18840   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18841 for as_dir in $PATH
18842 do
18843   IFS=$as_save_IFS
18844   test -z "$as_dir" && as_dir=.
18845     for ac_exec_ext in '' $ac_executable_extensions; do
18846   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18847     ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
18848     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18849     break 2
18850   fi
18851 done
18852   done
18853 IFS=$as_save_IFS
18854 
18855   ;;
18856 esac
18857 fi
18858 TIME=$ac_cv_path_TIME
18859 if test -n "$TIME"; then
18860   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
18861 $as_echo "$TIME" >&6; }
18862 else
18863   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18864 $as_echo "no" >&6; }
18865 fi
18866 
18867 
18868         if test "x$TIME" = x; then
18869           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
18870         fi
18871       else
18872         # Otherwise we believe it is a complete path. Use it as it is.
18873         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
18874 $as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
18875         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
18876 $as_echo_n "checking for TIME... " >&6; }
18877         if test ! -x "$tool_specified"; then
18878           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
18879 $as_echo "not found" >&6; }
18880           as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
18881         fi
18882         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
18883 $as_echo "$tool_specified" >&6; }
18884       fi
18885     fi
18886   fi
18887 
18888 
18889   # Check if it's GNU time
18890   IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
18891   if test "x$IS_GNU_TIME" != x; then
18892     IS_GNU_TIME=yes
18893   else
18894     IS_GNU_TIME=no
18895   fi
18896 
18897 
18898   if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
18899 
18900 
18901 
18902   # Publish this variable in the help.
18903 
18904 
18905   if test "x$DSYMUTIL" = x; then
18906     # The variable is not set by user, try to locate tool using the code snippet
18907     for ac_prog in dsymutil
18908 do
18909   # Extract the first word of "$ac_prog", so it can be a program name with args.
18910 set dummy $ac_prog; ac_word=$2
18911 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18912 $as_echo_n "checking for $ac_word... " >&6; }
18913 if ${ac_cv_path_DSYMUTIL+:} false; then :
18914   $as_echo_n "(cached) " >&6
18915 else
18916   case $DSYMUTIL in
18917   [\\/]* | ?:[\\/]*)
18918   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18919   ;;
18920   *)
18921   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18922 for as_dir in $PATH
18923 do
18924   IFS=$as_save_IFS
18925   test -z "$as_dir" && as_dir=.
18926     for ac_exec_ext in '' $ac_executable_extensions; do
18927   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18928     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18929     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18930     break 2
18931   fi
18932 done
18933   done
18934 IFS=$as_save_IFS
18935 
18936   ;;
18937 esac
18938 fi
18939 DSYMUTIL=$ac_cv_path_DSYMUTIL
18940 if test -n "$DSYMUTIL"; then
18941   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
18942 $as_echo "$DSYMUTIL" >&6; }
18943 else
18944   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18945 $as_echo "no" >&6; }
18946 fi
18947 
18948 
18949   test -n "$DSYMUTIL" && break
18950 done
18951 
18952   else
18953     # The variable is set, but is it from the command line or the environment?
18954 
18955     # Try to remove the string !DSYMUTIL! from our list.
18956     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!DSYMUTIL!/}
18957     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
18958       # If it failed, the variable was not from the command line. Ignore it,
18959       # but warn the user (except for BASH, which is always set by the calling BASH).
18960       if test "xDSYMUTIL" != xBASH; then
18961         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
18962 $as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
18963       fi
18964       # Try to locate tool using the code snippet
18965       for ac_prog in dsymutil
18966 do
18967   # Extract the first word of "$ac_prog", so it can be a program name with args.
18968 set dummy $ac_prog; ac_word=$2
18969 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
18970 $as_echo_n "checking for $ac_word... " >&6; }
18971 if ${ac_cv_path_DSYMUTIL+:} false; then :
18972   $as_echo_n "(cached) " >&6
18973 else
18974   case $DSYMUTIL in
18975   [\\/]* | ?:[\\/]*)
18976   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
18977   ;;
18978   *)
18979   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
18980 for as_dir in $PATH
18981 do
18982   IFS=$as_save_IFS
18983   test -z "$as_dir" && as_dir=.
18984     for ac_exec_ext in '' $ac_executable_extensions; do
18985   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
18986     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
18987     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
18988     break 2
18989   fi
18990 done
18991   done
18992 IFS=$as_save_IFS
18993 
18994   ;;
18995 esac
18996 fi
18997 DSYMUTIL=$ac_cv_path_DSYMUTIL
18998 if test -n "$DSYMUTIL"; then
18999   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
19000 $as_echo "$DSYMUTIL" >&6; }
19001 else
19002   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19003 $as_echo "no" >&6; }
19004 fi
19005 
19006 
19007   test -n "$DSYMUTIL" && break
19008 done
19009 
19010     else
19011       # If it succeeded, then it was overridden by the user. We will use it
19012       # for the tool.
19013 
19014       # First remove it from the list of overridden variables, so we can test
19015       # for unknown variables in the end.
19016       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19017 
19018       # Check if the provided tool contains a complete path.
19019       tool_specified="$DSYMUTIL"
19020       tool_basename="${tool_specified##*/}"
19021       if test "x$tool_basename" = "x$tool_specified"; then
19022         # A command without a complete path is provided, search $PATH.
19023         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
19024 $as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
19025         # Extract the first word of "$tool_basename", so it can be a program name with args.
19026 set dummy $tool_basename; ac_word=$2
19027 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19028 $as_echo_n "checking for $ac_word... " >&6; }
19029 if ${ac_cv_path_DSYMUTIL+:} false; then :
19030   $as_echo_n "(cached) " >&6
19031 else
19032   case $DSYMUTIL in
19033   [\\/]* | ?:[\\/]*)
19034   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
19035   ;;
19036   *)
19037   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19038 for as_dir in $PATH
19039 do
19040   IFS=$as_save_IFS
19041   test -z "$as_dir" && as_dir=.
19042     for ac_exec_ext in '' $ac_executable_extensions; do
19043   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19044     ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
19045     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19046     break 2
19047   fi
19048 done
19049   done
19050 IFS=$as_save_IFS
19051 
19052   ;;
19053 esac
19054 fi
19055 DSYMUTIL=$ac_cv_path_DSYMUTIL
19056 if test -n "$DSYMUTIL"; then
19057   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
19058 $as_echo "$DSYMUTIL" >&6; }
19059 else
19060   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19061 $as_echo "no" >&6; }
19062 fi
19063 
19064 
19065         if test "x$DSYMUTIL" = x; then
19066           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19067         fi
19068       else
19069         # Otherwise we believe it is a complete path. Use it as it is.
19070         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
19071 $as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
19072         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
19073 $as_echo_n "checking for DSYMUTIL... " >&6; }
19074         if test ! -x "$tool_specified"; then
19075           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19076 $as_echo "not found" >&6; }
19077           as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
19078         fi
19079         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19080 $as_echo "$tool_specified" >&6; }
19081       fi
19082     fi
19083   fi
19084 
19085 
19086 
19087   if test "x$DSYMUTIL" = x; then
19088     as_fn_error $? "Could not find required tool for DSYMUTIL" "$LINENO" 5
19089   fi
19090 
19091 
19092 
19093 
19094 
19095   # Publish this variable in the help.
19096 
19097 
19098   if test "x$XATTR" = x; then
19099     # The variable is not set by user, try to locate tool using the code snippet
19100     for ac_prog in xattr
19101 do
19102   # Extract the first word of "$ac_prog", so it can be a program name with args.
19103 set dummy $ac_prog; ac_word=$2
19104 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19105 $as_echo_n "checking for $ac_word... " >&6; }
19106 if ${ac_cv_path_XATTR+:} false; then :
19107   $as_echo_n "(cached) " >&6
19108 else
19109   case $XATTR in
19110   [\\/]* | ?:[\\/]*)
19111   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19112   ;;
19113   *)
19114   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19115 for as_dir in $PATH
19116 do
19117   IFS=$as_save_IFS
19118   test -z "$as_dir" && as_dir=.
19119     for ac_exec_ext in '' $ac_executable_extensions; do
19120   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19121     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19122     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19123     break 2
19124   fi
19125 done
19126   done
19127 IFS=$as_save_IFS
19128 
19129   ;;
19130 esac
19131 fi
19132 XATTR=$ac_cv_path_XATTR
19133 if test -n "$XATTR"; then
19134   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19135 $as_echo "$XATTR" >&6; }
19136 else
19137   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19138 $as_echo "no" >&6; }
19139 fi
19140 
19141 
19142   test -n "$XATTR" && break
19143 done
19144 
19145   else
19146     # The variable is set, but is it from the command line or the environment?
19147 
19148     # Try to remove the string !XATTR! from our list.
19149     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!XATTR!/}
19150     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19151       # If it failed, the variable was not from the command line. Ignore it,
19152       # but warn the user (except for BASH, which is always set by the calling BASH).
19153       if test "xXATTR" != xBASH; then
19154         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
19155 $as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
19156       fi
19157       # Try to locate tool using the code snippet
19158       for ac_prog in xattr
19159 do
19160   # Extract the first word of "$ac_prog", so it can be a program name with args.
19161 set dummy $ac_prog; ac_word=$2
19162 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19163 $as_echo_n "checking for $ac_word... " >&6; }
19164 if ${ac_cv_path_XATTR+:} false; then :
19165   $as_echo_n "(cached) " >&6
19166 else
19167   case $XATTR in
19168   [\\/]* | ?:[\\/]*)
19169   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19170   ;;
19171   *)
19172   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19173 for as_dir in $PATH
19174 do
19175   IFS=$as_save_IFS
19176   test -z "$as_dir" && as_dir=.
19177     for ac_exec_ext in '' $ac_executable_extensions; do
19178   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19179     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19180     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19181     break 2
19182   fi
19183 done
19184   done
19185 IFS=$as_save_IFS
19186 
19187   ;;
19188 esac
19189 fi
19190 XATTR=$ac_cv_path_XATTR
19191 if test -n "$XATTR"; then
19192   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19193 $as_echo "$XATTR" >&6; }
19194 else
19195   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19196 $as_echo "no" >&6; }
19197 fi
19198 
19199 
19200   test -n "$XATTR" && break
19201 done
19202 
19203     else
19204       # If it succeeded, then it was overridden by the user. We will use it
19205       # for the tool.
19206 
19207       # First remove it from the list of overridden variables, so we can test
19208       # for unknown variables in the end.
19209       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19210 
19211       # Check if the provided tool contains a complete path.
19212       tool_specified="$XATTR"
19213       tool_basename="${tool_specified##*/}"
19214       if test "x$tool_basename" = "x$tool_specified"; then
19215         # A command without a complete path is provided, search $PATH.
19216         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
19217 $as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
19218         # Extract the first word of "$tool_basename", so it can be a program name with args.
19219 set dummy $tool_basename; ac_word=$2
19220 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19221 $as_echo_n "checking for $ac_word... " >&6; }
19222 if ${ac_cv_path_XATTR+:} false; then :
19223   $as_echo_n "(cached) " >&6
19224 else
19225   case $XATTR in
19226   [\\/]* | ?:[\\/]*)
19227   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
19228   ;;
19229   *)
19230   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19231 for as_dir in $PATH
19232 do
19233   IFS=$as_save_IFS
19234   test -z "$as_dir" && as_dir=.
19235     for ac_exec_ext in '' $ac_executable_extensions; do
19236   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19237     ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
19238     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19239     break 2
19240   fi
19241 done
19242   done
19243 IFS=$as_save_IFS
19244 
19245   ;;
19246 esac
19247 fi
19248 XATTR=$ac_cv_path_XATTR
19249 if test -n "$XATTR"; then
19250   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
19251 $as_echo "$XATTR" >&6; }
19252 else
19253   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19254 $as_echo "no" >&6; }
19255 fi
19256 
19257 
19258         if test "x$XATTR" = x; then
19259           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19260         fi
19261       else
19262         # Otherwise we believe it is a complete path. Use it as it is.
19263         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
19264 $as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
19265         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
19266 $as_echo_n "checking for XATTR... " >&6; }
19267         if test ! -x "$tool_specified"; then
19268           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19269 $as_echo "not found" >&6; }
19270           as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
19271         fi
19272         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19273 $as_echo "$tool_specified" >&6; }
19274       fi
19275     fi
19276   fi
19277 
19278 
19279 
19280   if test "x$XATTR" = x; then
19281     as_fn_error $? "Could not find required tool for XATTR" "$LINENO" 5
19282   fi
19283 
19284 
19285 
19286 
19287   # Publish this variable in the help.
19288 
19289 
19290   if test "x$CODESIGN" = x; then
19291     # The variable is not set by user, try to locate tool using the code snippet
19292     for ac_prog in codesign
19293 do
19294   # Extract the first word of "$ac_prog", so it can be a program name with args.
19295 set dummy $ac_prog; ac_word=$2
19296 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19297 $as_echo_n "checking for $ac_word... " >&6; }
19298 if ${ac_cv_path_CODESIGN+:} false; then :
19299   $as_echo_n "(cached) " >&6
19300 else
19301   case $CODESIGN in
19302   [\\/]* | ?:[\\/]*)
19303   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19304   ;;
19305   *)
19306   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19307 for as_dir in $PATH
19308 do
19309   IFS=$as_save_IFS
19310   test -z "$as_dir" && as_dir=.
19311     for ac_exec_ext in '' $ac_executable_extensions; do
19312   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19313     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19314     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19315     break 2
19316   fi
19317 done
19318   done
19319 IFS=$as_save_IFS
19320 
19321   ;;
19322 esac
19323 fi
19324 CODESIGN=$ac_cv_path_CODESIGN
19325 if test -n "$CODESIGN"; then
19326   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19327 $as_echo "$CODESIGN" >&6; }
19328 else
19329   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19330 $as_echo "no" >&6; }
19331 fi
19332 
19333 
19334   test -n "$CODESIGN" && break
19335 done
19336 
19337   else
19338     # The variable is set, but is it from the command line or the environment?
19339 
19340     # Try to remove the string !CODESIGN! from our list.
19341     try_remove_var=${CONFIGURE_OVERRIDDEN_VARIABLES//!CODESIGN!/}
19342     if test "x$try_remove_var" = "x$CONFIGURE_OVERRIDDEN_VARIABLES"; then
19343       # If it failed, the variable was not from the command line. Ignore it,
19344       # but warn the user (except for BASH, which is always set by the calling BASH).
19345       if test "xCODESIGN" != xBASH; then
19346         { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
19347 $as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
19348       fi
19349       # Try to locate tool using the code snippet
19350       for ac_prog in codesign
19351 do
19352   # Extract the first word of "$ac_prog", so it can be a program name with args.
19353 set dummy $ac_prog; ac_word=$2
19354 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19355 $as_echo_n "checking for $ac_word... " >&6; }
19356 if ${ac_cv_path_CODESIGN+:} false; then :
19357   $as_echo_n "(cached) " >&6
19358 else
19359   case $CODESIGN in
19360   [\\/]* | ?:[\\/]*)
19361   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19362   ;;
19363   *)
19364   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19365 for as_dir in $PATH
19366 do
19367   IFS=$as_save_IFS
19368   test -z "$as_dir" && as_dir=.
19369     for ac_exec_ext in '' $ac_executable_extensions; do
19370   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19371     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19372     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19373     break 2
19374   fi
19375 done
19376   done
19377 IFS=$as_save_IFS
19378 
19379   ;;
19380 esac
19381 fi
19382 CODESIGN=$ac_cv_path_CODESIGN
19383 if test -n "$CODESIGN"; then
19384   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19385 $as_echo "$CODESIGN" >&6; }
19386 else
19387   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19388 $as_echo "no" >&6; }
19389 fi
19390 
19391 
19392   test -n "$CODESIGN" && break
19393 done
19394 
19395     else
19396       # If it succeeded, then it was overridden by the user. We will use it
19397       # for the tool.
19398 
19399       # First remove it from the list of overridden variables, so we can test
19400       # for unknown variables in the end.
19401       CONFIGURE_OVERRIDDEN_VARIABLES="$try_remove_var"
19402 
19403       # Check if the provided tool contains a complete path.
19404       tool_specified="$CODESIGN"
19405       tool_basename="${tool_specified##*/}"
19406       if test "x$tool_basename" = "x$tool_specified"; then
19407         # A command without a complete path is provided, search $PATH.
19408         { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
19409 $as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
19410         # Extract the first word of "$tool_basename", so it can be a program name with args.
19411 set dummy $tool_basename; ac_word=$2
19412 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19413 $as_echo_n "checking for $ac_word... " >&6; }
19414 if ${ac_cv_path_CODESIGN+:} false; then :
19415   $as_echo_n "(cached) " >&6
19416 else
19417   case $CODESIGN in
19418   [\\/]* | ?:[\\/]*)
19419   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
19420   ;;
19421   *)
19422   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19423 for as_dir in $PATH
19424 do
19425   IFS=$as_save_IFS
19426   test -z "$as_dir" && as_dir=.
19427     for ac_exec_ext in '' $ac_executable_extensions; do
19428   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19429     ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
19430     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19431     break 2
19432   fi
19433 done
19434   done
19435 IFS=$as_save_IFS
19436 
19437   ;;
19438 esac
19439 fi
19440 CODESIGN=$ac_cv_path_CODESIGN
19441 if test -n "$CODESIGN"; then
19442   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
19443 $as_echo "$CODESIGN" >&6; }
19444 else
19445   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19446 $as_echo "no" >&6; }
19447 fi
19448 
19449 
19450         if test "x$CODESIGN" = x; then
19451           as_fn_error $? "User supplied tool $tool_basename could not be found" "$LINENO" 5
19452         fi
19453       else
19454         # Otherwise we believe it is a complete path. Use it as it is.
19455         { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
19456 $as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
19457         { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
19458 $as_echo_n "checking for CODESIGN... " >&6; }
19459         if test ! -x "$tool_specified"; then
19460           { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19461 $as_echo "not found" >&6; }
19462           as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
19463         fi
19464         { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
19465 $as_echo "$tool_specified" >&6; }
19466       fi
19467     fi
19468   fi
19469 
19470 
19471     if test "x$CODESIGN" != "x"; then
19472       # Verify that the openjdk_codesign certificate is present
19473       { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
19474 $as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
19475       rm -f codesign-testfile
19476       touch codesign-testfile
19477       codesign -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
19478       rm -f codesign-testfile
19479       if test "x$CODESIGN" = x; then
19480         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19481 $as_echo "no" >&6; }
19482       else
19483         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19484 $as_echo "yes" >&6; }
19485       fi
19486     fi
19487   fi
19488 
19489 
19490   # Test if bash supports pipefail.
19491   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports pipefail" >&5
19492 $as_echo_n "checking if bash supports pipefail... " >&6; }
19493   if ${BASH} -c 'set -o pipefail'; then
19494     BASH_ARGS="$BASH_ARGS -o pipefail"
19495     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19496 $as_echo "yes" >&6; }
19497   else
19498     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19499 $as_echo "no" >&6; }
19500   fi
19501 
19502   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if bash supports errexit (-e)" >&5
19503 $as_echo_n "checking if bash supports errexit (-e)... " >&6; }
19504   if ${BASH} -e -c 'true'; then
19505     BASH_ARGS="$BASH_ARGS -e"
19506     { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19507 $as_echo "yes" >&6; }
19508   else
19509     { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19510 $as_echo "no" >&6; }
19511   fi
19512 
19513 
19514 
19515 
19516 # Check if pkg-config is available.
19517 
19518 
19519 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
19520         if test -n "$ac_tool_prefix"; then
19521   # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
19522 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
19523 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19524 $as_echo_n "checking for $ac_word... " >&6; }
19525 if ${ac_cv_path_PKG_CONFIG+:} false; then :
19526   $as_echo_n "(cached) " >&6
19527 else
19528   case $PKG_CONFIG in
19529   [\\/]* | ?:[\\/]*)
19530   ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
19531   ;;
19532   *)
19533   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19534 for as_dir in $PATH
19535 do
19536   IFS=$as_save_IFS
19537   test -z "$as_dir" && as_dir=.
19538     for ac_exec_ext in '' $ac_executable_extensions; do
19539   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19540     ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
19541     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19542     break 2
19543   fi
19544 done
19545   done
19546 IFS=$as_save_IFS
19547 
19548   ;;
19549 esac
19550 fi
19551 PKG_CONFIG=$ac_cv_path_PKG_CONFIG
19552 if test -n "$PKG_CONFIG"; then
19553   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
19554 $as_echo "$PKG_CONFIG" >&6; }
19555 else
19556   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19557 $as_echo "no" >&6; }
19558 fi
19559 
19560 
19561 fi
19562 if test -z "$ac_cv_path_PKG_CONFIG"; then
19563   ac_pt_PKG_CONFIG=$PKG_CONFIG
19564   # Extract the first word of "pkg-config", so it can be a program name with args.
19565 set dummy pkg-config; ac_word=$2
19566 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19567 $as_echo_n "checking for $ac_word... " >&6; }
19568 if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
19569   $as_echo_n "(cached) " >&6
19570 else
19571   case $ac_pt_PKG_CONFIG in
19572   [\\/]* | ?:[\\/]*)
19573   ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
19574   ;;
19575   *)
19576   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19577 for as_dir in $PATH
19578 do
19579   IFS=$as_save_IFS
19580   test -z "$as_dir" && as_dir=.
19581     for ac_exec_ext in '' $ac_executable_extensions; do
19582   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19583     ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
19584     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19585     break 2
19586   fi
19587 done
19588   done
19589 IFS=$as_save_IFS
19590 
19591   ;;
19592 esac
19593 fi
19594 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
19595 if test -n "$ac_pt_PKG_CONFIG"; then
19596   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
19597 $as_echo "$ac_pt_PKG_CONFIG" >&6; }
19598 else
19599   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19600 $as_echo "no" >&6; }
19601 fi
19602 
19603   if test "x$ac_pt_PKG_CONFIG" = x; then
19604     PKG_CONFIG=""
19605   else
19606     case $cross_compiling:$ac_tool_warned in
19607 yes:)
19608 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
19609 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
19610 ac_tool_warned=yes ;;
19611 esac
19612     PKG_CONFIG=$ac_pt_PKG_CONFIG
19613   fi
19614 else
19615   PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
19616 fi
19617 
19618 fi
19619 if test -n "$PKG_CONFIG"; then
19620         _pkg_min_version=0.9.0
19621         { $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
19622 $as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
19623         if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
19624                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19625 $as_echo "yes" >&6; }
19626         else
19627                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19628 $as_echo "no" >&6; }
19629                 PKG_CONFIG=""
19630         fi
19631 
19632 fi
19633 
19634 # After basic tools have been setup, we can check build os specific details.
19635 
19636   ###############################################################################
19637 
19638   # Note that this is the build platform OS version!
19639 
19640   OS_VERSION="`uname -r | ${SED} 's!\.! !g' | ${SED} 's!-! !g'`"
19641   OS_VERSION_MAJOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 1 -d ' '`"
19642   OS_VERSION_MINOR="`${ECHO} ${OS_VERSION} | ${CUT} -f 2 -d ' '`"
19643   OS_VERSION_MICRO="`${ECHO} ${OS_VERSION} | ${CUT} -f 3 -d ' '`"
19644 
19645 
19646 
19647 
19648 
19649 # Setup builddeps, for automatic downloading of tools we need.
19650 # This is needed before we can call BDEPS_CHECK_MODULE, which is done in
19651 # boot-jdk setup, but we need to have basic tools setup first.
19652 
19653 
19654 # Check whether --with-builddeps-conf was given.
19655 if test "${with_builddeps_conf+set}" = set; then :
19656   withval=$with_builddeps_conf;
19657 fi
19658 
19659 
19660 
19661 # Check whether --with-builddeps-server was given.
19662 if test "${with_builddeps_server+set}" = set; then :
19663   withval=$with_builddeps_server;
19664 fi
19665 
19666 
19667 
19668 # Check whether --with-builddeps-dir was given.
19669 if test "${with_builddeps_dir+set}" = set; then :
19670   withval=$with_builddeps_dir;
19671 else
19672   with_builddeps_dir=/localhome/builddeps
19673 fi
19674 
19675 
19676 
19677 # Check whether --with-builddeps-group was given.
19678 if test "${with_builddeps_group+set}" = set; then :
19679   withval=$with_builddeps_group;
19680 fi
19681 
19682 
19683 
19684 
19685   if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
19686     if test "x$with_builddeps_conf" != x; then
19687       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for supplied builddeps configuration file" >&5
19688 $as_echo_n "checking for supplied builddeps configuration file... " >&6; }
19689       builddepsfile=$with_builddeps_conf
19690       if test -s $builddepsfile; then
19691         . $builddepsfile
19692         { $as_echo "$as_me:${as_lineno-$LINENO}: result: loaded!" >&5
19693 $as_echo "loaded!" >&6; }
19694       else
19695         as_fn_error $? "The given builddeps conf file $with_builddeps_conf could not be loaded!" "$LINENO" 5
19696       fi
19697     else
19698       { $as_echo "$as_me:${as_lineno-$LINENO}: checking for builddeps.conf files in sources..." >&5
19699 $as_echo_n "checking for builddeps.conf files in sources...... " >&6; }
19700       builddepsfile=`mktemp`
19701       touch $builddepsfile
19702       # Put all found confs into a single file.
19703       find ${SRC_ROOT} -name builddeps.conf -exec cat \{\} \; >> $builddepsfile
19704       # Source the file to acquire the variables
19705       if test -s $builddepsfile; then
19706         . $builddepsfile
19707         { $as_echo "$as_me:${as_lineno-$LINENO}: result: found at least one!" >&5
19708 $as_echo "found at least one!" >&6; }
19709       else
19710         as_fn_error $? "Could not find any builddeps.conf at all!" "$LINENO" 5
19711       fi
19712     fi
19713     # Create build and target names that use _ instead of "-" and ".".
19714     # This is necessary to use them in variable names.
19715     build_var=`echo ${OPENJDK_BUILD_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19716     target_var=`echo ${OPENJDK_TARGET_AUTOCONF_NAME} | tr '-' '_' | tr '.' '_'`
19717     # Extract rewrite information for build and target
19718     eval rewritten_build=\${REWRITE_${build_var}}
19719     if test "x$rewritten_build" = x; then
19720       rewritten_build=${OPENJDK_BUILD_AUTOCONF_NAME}
19721       echo Build stays the same $rewritten_build
19722     else
19723       echo Rewriting build for builddeps into $rewritten_build
19724     fi
19725     eval rewritten_target=\${REWRITE_${target_var}}
19726     if test "x$rewritten_target" = x; then
19727       rewritten_target=${OPENJDK_TARGET_AUTOCONF_NAME}
19728       echo Target stays the same $rewritten_target
19729     else
19730       echo Rewriting target for builddeps into $rewritten_target
19731     fi
19732     rewritten_build_var=`echo ${rewritten_build} | tr '-' '_' | tr '.' '_'`
19733     rewritten_target_var=`echo ${rewritten_target} | tr '-' '_' | tr '.' '_'`
19734   fi
19735   for ac_prog in 7z unzip
19736 do
19737   # Extract the first word of "$ac_prog", so it can be a program name with args.
19738 set dummy $ac_prog; ac_word=$2
19739 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19740 $as_echo_n "checking for $ac_word... " >&6; }
19741 if ${ac_cv_prog_BDEPS_UNZIP+:} false; then :
19742   $as_echo_n "(cached) " >&6
19743 else
19744   if test -n "$BDEPS_UNZIP"; then
19745   ac_cv_prog_BDEPS_UNZIP="$BDEPS_UNZIP" # Let the user override the test.
19746 else
19747 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19748 for as_dir in $PATH
19749 do
19750   IFS=$as_save_IFS
19751   test -z "$as_dir" && as_dir=.
19752     for ac_exec_ext in '' $ac_executable_extensions; do
19753   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19754     ac_cv_prog_BDEPS_UNZIP="$ac_prog"
19755     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19756     break 2
19757   fi
19758 done
19759   done
19760 IFS=$as_save_IFS
19761 
19762 fi
19763 fi
19764 BDEPS_UNZIP=$ac_cv_prog_BDEPS_UNZIP
19765 if test -n "$BDEPS_UNZIP"; then
19766   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_UNZIP" >&5
19767 $as_echo "$BDEPS_UNZIP" >&6; }
19768 else
19769   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19770 $as_echo "no" >&6; }
19771 fi
19772 
19773 
19774   test -n "$BDEPS_UNZIP" && break
19775 done
19776 
19777   if test "x$BDEPS_UNZIP" = x7z; then
19778     BDEPS_UNZIP="7z x"
19779   fi
19780 
19781   for ac_prog in wget lftp ftp
19782 do
19783   # Extract the first word of "$ac_prog", so it can be a program name with args.
19784 set dummy $ac_prog; ac_word=$2
19785 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
19786 $as_echo_n "checking for $ac_word... " >&6; }
19787 if ${ac_cv_prog_BDEPS_FTP+:} false; then :
19788   $as_echo_n "(cached) " >&6
19789 else
19790   if test -n "$BDEPS_FTP"; then
19791   ac_cv_prog_BDEPS_FTP="$BDEPS_FTP" # Let the user override the test.
19792 else
19793 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
19794 for as_dir in $PATH
19795 do
19796   IFS=$as_save_IFS
19797   test -z "$as_dir" && as_dir=.
19798     for ac_exec_ext in '' $ac_executable_extensions; do
19799   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
19800     ac_cv_prog_BDEPS_FTP="$ac_prog"
19801     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
19802     break 2
19803   fi
19804 done
19805   done
19806 IFS=$as_save_IFS
19807 
19808 fi
19809 fi
19810 BDEPS_FTP=$ac_cv_prog_BDEPS_FTP
19811 if test -n "$BDEPS_FTP"; then
19812   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_FTP" >&5
19813 $as_echo "$BDEPS_FTP" >&6; }
19814 else
19815   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19816 $as_echo "no" >&6; }
19817 fi
19818 
19819 
19820   test -n "$BDEPS_FTP" && break
19821 done
19822 
19823 
19824 
19825 ###############################################################################
19826 #
19827 # Determine OpenJDK variants, options and version numbers.
19828 #
19829 ###############################################################################
19830 
19831 # We need build & target for this.
19832 
19833 
19834   ###############################################################################
19835   #
19836   # Should we build a JDK/JVM with headful support (ie a graphical ui)?
19837   # We always build headless support.
19838   #
19839   { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
19840 $as_echo_n "checking headful support... " >&6; }
19841   # Check whether --enable-headful was given.
19842 if test "${enable_headful+set}" = set; then :
19843   enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
19844 else
19845   SUPPORT_HEADFUL=yes
19846 fi
19847 
19848 
19849   SUPPORT_HEADLESS=yes
19850   BUILD_HEADLESS="BUILD_HEADLESS:=true"
19851 
19852   if test "x$SUPPORT_HEADFUL" = xyes; then
19853     # We are building both headful and headless.
19854     headful_msg="include support for both headful and headless"
19855   fi
19856 
19857   if test "x$SUPPORT_HEADFUL" = xno; then
19858     # Thus we are building headless only.
19859     BUILD_HEADLESS="BUILD_HEADLESS:=true"
19860     headful_msg="headless only"
19861   fi
19862 
19863   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
19864 $as_echo "$headful_msg" >&6; }
19865 
19866 
19867 
19868 
19869 
19870   # Control wether Hotspot runs Queens test after build.
19871   # Check whether --enable-hotspot-test-in-build was given.
19872 if test "${enable_hotspot_test_in_build+set}" = set; then :
19873   enableval=$enable_hotspot_test_in_build;
19874 else
19875   enable_hotspot_test_in_build=no
19876 fi
19877 
19878   if test "x$enable_hotspot_test_in_build" = "xyes"; then
19879     TEST_IN_BUILD=true
19880   else
19881     TEST_IN_BUILD=false
19882   fi
19883 
19884 
19885   ###############################################################################
19886   #
19887   # Choose cacerts source file
19888   #
19889 
19890 # Check whether --with-cacerts-file was given.
19891 if test "${with_cacerts_file+set}" = set; then :
19892   withval=$with_cacerts_file;
19893 fi
19894 
19895   if test "x$with_cacerts_file" != x; then
19896     CACERTS_FILE=$with_cacerts_file
19897   fi
19898 
19899 
19900   ###############################################################################
19901   #
19902   # Enable or disable unlimited crypto
19903   #
19904   # Check whether --enable-unlimited-crypto was given.
19905 if test "${enable_unlimited_crypto+set}" = set; then :
19906   enableval=$enable_unlimited_crypto;
19907 else
19908   enable_unlimited_crypto=no
19909 fi
19910 
19911   if test "x$enable_unlimited_crypto" = "xyes"; then
19912     UNLIMITED_CRYPTO=true
19913   else
19914     UNLIMITED_CRYPTO=false
19915   fi
19916 
19917 
19918   ###############################################################################
19919   #
19920   # Enable or disable the elliptic curve crypto implementation
19921   #
19922 
19923 
19924   ###############################################################################
19925   #
19926   # --enable-rmiconnector-iiop
19927   #
19928   # Check whether --enable-rmiconnector-iiop was given.
19929 if test "${enable_rmiconnector_iiop+set}" = set; then :
19930   enableval=$enable_rmiconnector_iiop;
19931 fi
19932 
19933   if test "x$enable_rmiconnector_iiop" = "xyes"; then
19934     RMICONNECTOR_IIOP=true
19935   else
19936     RMICONNECTOR_IIOP=false
19937   fi
19938 
19939 
19940   ###############################################################################
19941   #
19942   # Compress jars
19943   #
19944   COMPRESS_JARS=false
19945 
19946 
19947 
19948 
19949   # Source the version numbers
19950   . $AUTOCONF_DIR/version-numbers
19951 
19952   # Get the settings from parameters
19953 
19954 # Check whether --with-milestone was given.
19955 if test "${with_milestone+set}" = set; then :
19956   withval=$with_milestone;
19957 fi
19958 
19959   if test "x$with_milestone" = xyes; then
19960     as_fn_error $? "Milestone must have a value" "$LINENO" 5
19961   elif test "x$with_milestone" != x; then
19962     MILESTONE="$with_milestone"
19963   fi
19964   if test "x$MILESTONE" = x; then
19965     MILESTONE=internal
19966   fi
19967 
19968 
19969 # Check whether --with-update-version was given.
19970 if test "${with_update_version+set}" = set; then :
19971   withval=$with_update_version;
19972 fi
19973 
19974   if test "x$with_update_version" = xyes; then
19975     as_fn_error $? "Update version must have a value" "$LINENO" 5
19976   elif test "x$with_update_version" != x; then
19977     JDK_UPDATE_VERSION="$with_update_version"
19978     # On macosx 10.7, it's not possible to set --with-update-version=0X due
19979     # to a bug in expr (which reduces it to just X). To work around this, we
19980     # always add a 0 to one digit update versions.
19981     if test "${#JDK_UPDATE_VERSION}" = "1"; then
19982       JDK_UPDATE_VERSION="0${JDK_UPDATE_VERSION}"
19983     fi
19984   fi
19985 
19986 
19987 # Check whether --with-user-release-suffix was given.
19988 if test "${with_user_release_suffix+set}" = set; then :
19989   withval=$with_user_release_suffix;
19990 fi
19991 
19992   if test "x$with_user_release_suffix" = xyes; then
19993     as_fn_error $? "Release suffix must have a value" "$LINENO" 5
19994   elif test "x$with_user_release_suffix" != x; then
19995     USER_RELEASE_SUFFIX="$with_user_release_suffix"
19996   fi
19997 
19998 
19999 # Check whether --with-build-number was given.
20000 if test "${with_build_number+set}" = set; then :
20001   withval=$with_build_number;
20002 fi
20003 
20004   if test "x$with_build_number" = xyes; then
20005     as_fn_error $? "Build number must have a value" "$LINENO" 5
20006   elif test "x$with_build_number" != x; then
20007     JDK_BUILD_NUMBER="$with_build_number"
20008   fi
20009   # Define default USER_RELEASE_SUFFIX if BUILD_NUMBER and USER_RELEASE_SUFFIX are not set
20010   if test "x$JDK_BUILD_NUMBER" = x; then
20011     JDK_BUILD_NUMBER=b00
20012     if test "x$USER_RELEASE_SUFFIX" = x; then
20013       BUILD_DATE=`date '+%Y_%m_%d_%H_%M'`
20014       # Avoid [:alnum:] since it depends on the locale.
20015       CLEAN_USERNAME=`echo "$USER" | $TR -d -c 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'`
20016       USER_RELEASE_SUFFIX=`echo "${CLEAN_USERNAME}_${BUILD_DATE}" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20017     fi
20018   fi
20019 
20020   # Now set the JDK version, milestone, build number etc.
20021 
20022 
20023 
20024 
20025 
20026 
20027 
20028 
20029 
20030 
20031 
20032 
20033 
20034 
20035 
20036 
20037 # Check whether --with-copyright-year was given.
20038 if test "${with_copyright_year+set}" = set; then :
20039   withval=$with_copyright_year;
20040 fi
20041 
20042   if test "x$with_copyright_year" = xyes; then
20043     as_fn_error $? "Copyright year must have a value" "$LINENO" 5
20044   elif test "x$with_copyright_year" != x; then
20045     COPYRIGHT_YEAR="$with_copyright_year"
20046   else
20047     COPYRIGHT_YEAR=`date +'%Y'`
20048   fi
20049 
20050 
20051   if test "x$JDK_UPDATE_VERSION" != x; then
20052     JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}_${JDK_UPDATE_VERSION}"
20053   else
20054     JDK_VERSION="${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_MICRO_VERSION}"
20055   fi
20056 
20057 
20058   COOKED_BUILD_NUMBER=`$ECHO $JDK_BUILD_NUMBER | $SED -e 's/^b//' -e 's/^0//'`
20059 
20060 
20061 
20062 ###############################################################################
20063 #
20064 # Setup BootJDK, used to bootstrap the build.
20065 #
20066 ###############################################################################
20067 
20068 
20069   BOOT_JDK_FOUND=no
20070 
20071 # Check whether --with-boot-jdk was given.
20072 if test "${with_boot_jdk+set}" = set; then :
20073   withval=$with_boot_jdk;
20074 fi
20075 
20076 
20077   # We look for the Boot JDK through various means, going from more certain to
20078   # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
20079   # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
20080   # must check if this is indeed valid; otherwise we'll continue looking.
20081 
20082   # Test: Is bootjdk explicitely set by command line arguments?
20083 
20084   if test "x$BOOT_JDK_FOUND" = xno; then
20085     # Now execute the test
20086 
20087   if test "x$with_boot_jdk" != x; then
20088     BOOT_JDK=$with_boot_jdk
20089     BOOT_JDK_FOUND=maybe
20090     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
20091 $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
20092   fi
20093 
20094 
20095     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20096     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20097       # Do we have a bin/java?
20098       if test ! -x "$BOOT_JDK/bin/java"; then
20099         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20100 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20101         BOOT_JDK_FOUND=no
20102       else
20103         # Do we have a bin/javac?
20104         if test ! -x "$BOOT_JDK/bin/javac"; then
20105           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20106 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20107           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20108 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20109           BOOT_JDK_FOUND=no
20110         else
20111           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20112           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20113 
20114           # Extra M4 quote needed to protect [] in grep expression.
20115           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
20116           if test "x$FOUND_CORRECT_VERSION" = x; then
20117             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20118 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20119             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20120 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20121             BOOT_JDK_FOUND=no
20122           else
20123             # We're done! :-)
20124             BOOT_JDK_FOUND=yes
20125 
20126   # Only process if variable expands to non-empty
20127 
20128   if test "x$BOOT_JDK" != x; then
20129     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20130 
20131   # Input might be given as Windows format, start by converting to
20132   # unix format.
20133   path="$BOOT_JDK"
20134   new_path=`$CYGPATH -u "$path"`
20135 
20136   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20137   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20138   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20139   # "foo.exe" is OK but "foo" is an error.
20140   #
20141   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20142   # It is also a way to make sure we got the proper file name for the real test later on.
20143   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20144   if test "x$test_shortpath" = x; then
20145     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20146 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20147     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20148   fi
20149 
20150   # Call helper function which possibly converts this using DOS-style short mode.
20151   # If so, the updated path is stored in $new_path.
20152 
20153   input_path="$new_path"
20154   # Check if we need to convert this using DOS-style short mode. If the path
20155   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20156   # take no chances and rewrite it.
20157   # Note: m4 eats our [], so we need to use [ and ] instead.
20158   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20159   if test "x$has_forbidden_chars" != x; then
20160     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20161     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20162     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20163     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20164       # Going to short mode and back again did indeed matter. Since short mode is
20165       # case insensitive, let's make it lowercase to improve readability.
20166       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20167       # Now convert it back to Unix-stile (cygpath)
20168       input_path=`$CYGPATH -u "$shortmode_path"`
20169       new_path="$input_path"
20170     fi
20171   fi
20172 
20173   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20174   if test "x$test_cygdrive_prefix" = x; then
20175     # As a simple fix, exclude /usr/bin since it's not a real path.
20176     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20177       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20178       # a path prefixed by /cygdrive for fixpath to work.
20179       new_path="$CYGWIN_ROOT_PATH$input_path"
20180     fi
20181   fi
20182 
20183 
20184   if test "x$path" != "x$new_path"; then
20185     BOOT_JDK="$new_path"
20186     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20187 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20188   fi
20189 
20190     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20191 
20192   path="$BOOT_JDK"
20193   has_colon=`$ECHO $path | $GREP ^.:`
20194   new_path="$path"
20195   if test "x$has_colon" = x; then
20196     # Not in mixed or Windows style, start by that.
20197     new_path=`cmd //c echo $path`
20198   fi
20199 
20200 
20201   input_path="$new_path"
20202   # Check if we need to convert this using DOS-style short mode. If the path
20203   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20204   # take no chances and rewrite it.
20205   # Note: m4 eats our [], so we need to use [ and ] instead.
20206   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20207   if test "x$has_forbidden_chars" != x; then
20208     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20209     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20210   fi
20211 
20212 
20213   windows_path="$new_path"
20214   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20215     unix_path=`$CYGPATH -u "$windows_path"`
20216     new_path="$unix_path"
20217   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20218     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20219     new_path="$unix_path"
20220   fi
20221 
20222   if test "x$path" != "x$new_path"; then
20223     BOOT_JDK="$new_path"
20224     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20225 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20226   fi
20227 
20228   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20229   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20230 
20231     else
20232       # We're on a unix platform. Hooray! :)
20233       path="$BOOT_JDK"
20234       has_space=`$ECHO "$path" | $GREP " "`
20235       if test "x$has_space" != x; then
20236         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20237 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20238         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20239       fi
20240 
20241       # Use eval to expand a potential ~
20242       eval path="$path"
20243       if test ! -f "$path" && test ! -d "$path"; then
20244         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20245       fi
20246 
20247       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20248     fi
20249   fi
20250 
20251             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20252 $as_echo_n "checking for Boot JDK... " >&6; }
20253             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20254 $as_echo "$BOOT_JDK" >&6; }
20255             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20256 $as_echo_n "checking Boot JDK version... " >&6; }
20257             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20258             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20259 $as_echo "$BOOT_JDK_VERSION" >&6; }
20260           fi # end check jdk version
20261         fi # end check javac
20262       fi # end check java
20263     fi # end check boot jdk found
20264   fi
20265 
20266   if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
20267     # Having specified an argument which is incorrect will produce an instant failure;
20268     # we should not go on looking
20269     as_fn_error $? "The path given by --with-boot-jdk does not contain a valid Boot JDK" "$LINENO" 5
20270   fi
20271 
20272   # Test: Is bootjdk available from builddeps?
20273 
20274   if test "x$BOOT_JDK_FOUND" = xno; then
20275     # Now execute the test
20276 
20277 
20278 
20279   if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
20280     # Source the builddeps file again, to make sure it uses the latest variables!
20281     . $builddepsfile
20282     # Look for a target and build machine specific resource!
20283     eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}_TARGET_${rewritten_target_var}}
20284     if test "x$resource" = x; then
20285       # Ok, lets instead look for a target specific resource
20286       eval resource=\${builddep_bootjdk_TARGET_${rewritten_target_var}}
20287     fi
20288     if test "x$resource" = x; then
20289       # Ok, lets instead look for a build specific resource
20290       eval resource=\${builddep_bootjdk_BUILD_${rewritten_build_var}}
20291     fi
20292     if test "x$resource" = x; then
20293       # Ok, lets instead look for a generic resource
20294       # (The bootjdk comes from M4 and not the shell, thus no need for eval here.)
20295       resource=${builddep_bootjdk}
20296     fi
20297     if test "x$resource" != x; then
20298       { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for bootjdk" >&5
20299 $as_echo "$as_me: Using builddeps $resource for bootjdk" >&6;}
20300       # If the resource in the builddeps.conf file is an existing directory,
20301       # for example /java/linux/cups
20302       if test -d ${resource}; then
20303         depdir=${resource}
20304       else
20305 
20306   # bootjdk is for example mymodule
20307   # $resource is for example libs/general/libmymod_1_2_3.zip
20308   # $with_builddeps_server is for example ftp://mybuilddeps.myserver.com/builddeps
20309   # $with_builddeps_dir is for example /localhome/builddeps
20310   # depdir is the name of the variable into which we store the depdir, eg MYMOD
20311   # Will download ftp://mybuilddeps.myserver.com/builddeps/libs/general/libmymod_1_2_3.zip and
20312   # unzip into the directory: /localhome/builddeps/libmymod_1_2_3
20313   filename=`basename $resource`
20314   filebase=`echo $filename | sed 's/\.[^\.]*$//'`
20315   filebase=${filename%%.*}
20316   extension=${filename#*.}
20317   installdir=$with_builddeps_dir/$filebase
20318   if test ! -f $installdir/$filename.unpacked; then
20319     { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&5
20320 $as_echo "$as_me: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&6;}
20321     if test ! -d $installdir; then
20322       mkdir -p $installdir
20323     fi
20324     if test ! -d $installdir; then
20325       as_fn_error $? "Could not create directory $installdir" "$LINENO" 5
20326     fi
20327     tmpfile=`mktemp $installdir/bootjdk.XXXXXXXXX`
20328     touch $tmpfile
20329     if test ! -f $tmpfile; then
20330       as_fn_error $? "Could not create files in directory $installdir" "$LINENO" 5
20331     fi
20332 
20333   # $with_builddeps_server/$resource  is the ftp://abuilddeps.server.com/libs/cups.zip
20334   # $tmpfile is the local file name for the downloaded file.
20335   VALID_TOOL=no
20336   if test "x$BDEPS_FTP" = xwget; then
20337     VALID_TOOL=yes
20338     wget -O $tmpfile $with_builddeps_server/$resource
20339   fi
20340   if test "x$BDEPS_FTP" = xlftp; then
20341     VALID_TOOL=yes
20342     lftp -c "get $with_builddeps_server/$resource  -o $tmpfile"
20343   fi
20344   if test "x$BDEPS_FTP" = xftp; then
20345     VALID_TOOL=yes
20346     FTPSERVER=`echo $with_builddeps_server/$resource  | cut -f 3 -d '/'`
20347     FTPPATH=`echo $with_builddeps_server/$resource  | cut -f 4- -d '/'`
20348     FTPUSERPWD=${FTPSERVER%%@*}
20349     if test "x$FTPSERVER" != "x$FTPUSERPWD"; then
20350       FTPUSER=${userpwd%%:*}
20351       FTPPWD=${userpwd#*@}
20352       FTPSERVER=${FTPSERVER#*@}
20353     else
20354       FTPUSER=ftp
20355       FTPPWD=ftp
20356     fi
20357     # the "pass" command does not work on some
20358     # ftp clients (read ftp.exe) but if it works,
20359     # passive mode is better!
20360     ( \
20361         echo "user $FTPUSER $FTPPWD"        ; \
20362         echo "pass"                         ; \
20363         echo "bin"                          ; \
20364         echo "get $FTPPATH $tmpfile"              ; \
20365     ) | ftp -in $FTPSERVER
20366   fi
20367   if test "x$VALID_TOOL" != xyes; then
20368     as_fn_error $? "I do not know how to use the tool: $BDEPS_FTP" "$LINENO" 5
20369   fi
20370 
20371     mv $tmpfile $installdir/$filename
20372     if test ! -s $installdir/$filename; then
20373       as_fn_error $? "Could not download $with_builddeps_server/$resource" "$LINENO" 5
20374     fi
20375     case "$extension" in
20376       zip)  echo "Unzipping $installdir/$filename..."
20377         (cd $installdir ; rm -f $installdir/$filename.unpacked ; $BDEPS_UNZIP $installdir/$filename > /dev/null && touch $installdir/$filename.unpacked)
20378         ;;
20379       tar.gz) echo "Untaring $installdir/$filename..."
20380         (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
20381         ;;
20382       tgz) echo "Untaring $installdir/$filename..."
20383         (cd $installdir ; rm -f $installdir/$filename.unpacked ; tar xzf $installdir/$filename && touch $installdir/$filename.unpacked)
20384         ;;
20385       *) as_fn_error $? "Cannot handle build depency archive with extension $extension" "$LINENO" 5
20386         ;;
20387     esac
20388   fi
20389   if test -f $installdir/$filename.unpacked; then
20390     depdir=$installdir
20391   fi
20392 
20393       fi
20394       # Source the builddeps file again, because in the previous command, the depdir
20395       # was updated to point at the current build dependency install directory.
20396       . $builddepsfile
20397       # Now extract variables from the builddeps.conf files.
20398       theroot=${builddep_bootjdk_ROOT}
20399       thecflags=${builddep_bootjdk_CFLAGS}
20400       thelibs=${builddep_bootjdk_LIBS}
20401       if test "x$depdir" = x; then
20402         as_fn_error $? "Could not download build dependency bootjdk" "$LINENO" 5
20403       fi
20404       BOOT_JDK=$depdir
20405       if test "x$theroot" != x; then
20406         BOOT_JDK="$theroot"
20407       fi
20408       if test "x$thecflags" != x; then
20409         BOOT_JDK_CFLAGS="$thecflags"
20410       fi
20411       if test "x$thelibs" != x; then
20412         BOOT_JDK_LIBS="$thelibs"
20413       fi
20414       BOOT_JDK_FOUND=maybe
20415       else BOOT_JDK_FOUND=no
20416 
20417     fi
20418     else BOOT_JDK_FOUND=no
20419 
20420   fi
20421 
20422 
20423 
20424     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20425     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20426       # Do we have a bin/java?
20427       if test ! -x "$BOOT_JDK/bin/java"; then
20428         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20429 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20430         BOOT_JDK_FOUND=no
20431       else
20432         # Do we have a bin/javac?
20433         if test ! -x "$BOOT_JDK/bin/javac"; then
20434           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20435 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20436           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20437 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20438           BOOT_JDK_FOUND=no
20439         else
20440           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20441           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20442 
20443           # Extra M4 quote needed to protect [] in grep expression.
20444           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
20445           if test "x$FOUND_CORRECT_VERSION" = x; then
20446             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20447 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20448             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20449 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20450             BOOT_JDK_FOUND=no
20451           else
20452             # We're done! :-)
20453             BOOT_JDK_FOUND=yes
20454 
20455   # Only process if variable expands to non-empty
20456 
20457   if test "x$BOOT_JDK" != x; then
20458     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20459 
20460   # Input might be given as Windows format, start by converting to
20461   # unix format.
20462   path="$BOOT_JDK"
20463   new_path=`$CYGPATH -u "$path"`
20464 
20465   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20466   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20467   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20468   # "foo.exe" is OK but "foo" is an error.
20469   #
20470   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20471   # It is also a way to make sure we got the proper file name for the real test later on.
20472   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20473   if test "x$test_shortpath" = x; then
20474     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20475 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20476     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20477   fi
20478 
20479   # Call helper function which possibly converts this using DOS-style short mode.
20480   # If so, the updated path is stored in $new_path.
20481 
20482   input_path="$new_path"
20483   # Check if we need to convert this using DOS-style short mode. If the path
20484   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20485   # take no chances and rewrite it.
20486   # Note: m4 eats our [], so we need to use [ and ] instead.
20487   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20488   if test "x$has_forbidden_chars" != x; then
20489     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20490     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20491     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20492     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20493       # Going to short mode and back again did indeed matter. Since short mode is
20494       # case insensitive, let's make it lowercase to improve readability.
20495       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20496       # Now convert it back to Unix-stile (cygpath)
20497       input_path=`$CYGPATH -u "$shortmode_path"`
20498       new_path="$input_path"
20499     fi
20500   fi
20501 
20502   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20503   if test "x$test_cygdrive_prefix" = x; then
20504     # As a simple fix, exclude /usr/bin since it's not a real path.
20505     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20506       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20507       # a path prefixed by /cygdrive for fixpath to work.
20508       new_path="$CYGWIN_ROOT_PATH$input_path"
20509     fi
20510   fi
20511 
20512 
20513   if test "x$path" != "x$new_path"; then
20514     BOOT_JDK="$new_path"
20515     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20516 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20517   fi
20518 
20519     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20520 
20521   path="$BOOT_JDK"
20522   has_colon=`$ECHO $path | $GREP ^.:`
20523   new_path="$path"
20524   if test "x$has_colon" = x; then
20525     # Not in mixed or Windows style, start by that.
20526     new_path=`cmd //c echo $path`
20527   fi
20528 
20529 
20530   input_path="$new_path"
20531   # Check if we need to convert this using DOS-style short mode. If the path
20532   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20533   # take no chances and rewrite it.
20534   # Note: m4 eats our [], so we need to use [ and ] instead.
20535   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20536   if test "x$has_forbidden_chars" != x; then
20537     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20538     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20539   fi
20540 
20541 
20542   windows_path="$new_path"
20543   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20544     unix_path=`$CYGPATH -u "$windows_path"`
20545     new_path="$unix_path"
20546   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20547     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20548     new_path="$unix_path"
20549   fi
20550 
20551   if test "x$path" != "x$new_path"; then
20552     BOOT_JDK="$new_path"
20553     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20554 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20555   fi
20556 
20557   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20558   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20559 
20560     else
20561       # We're on a unix platform. Hooray! :)
20562       path="$BOOT_JDK"
20563       has_space=`$ECHO "$path" | $GREP " "`
20564       if test "x$has_space" != x; then
20565         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20566 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20567         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20568       fi
20569 
20570       # Use eval to expand a potential ~
20571       eval path="$path"
20572       if test ! -f "$path" && test ! -d "$path"; then
20573         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20574       fi
20575 
20576       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20577     fi
20578   fi
20579 
20580             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20581 $as_echo_n "checking for Boot JDK... " >&6; }
20582             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20583 $as_echo "$BOOT_JDK" >&6; }
20584             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20585 $as_echo_n "checking Boot JDK version... " >&6; }
20586             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20587             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20588 $as_echo "$BOOT_JDK_VERSION" >&6; }
20589           fi # end check jdk version
20590         fi # end check javac
20591       fi # end check java
20592     fi # end check boot jdk found
20593   fi
20594 
20595 
20596   # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
20597 
20598   if test "x$BOOT_JDK_FOUND" = xno; then
20599     # Now execute the test
20600 
20601   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
20602     # First check at user selected default
20603 
20604   if test "x$BOOT_JDK_FOUND" = xno; then
20605     # Now execute the test
20606 
20607   if test -x /usr/libexec/java_home; then
20608     BOOT_JDK=`/usr/libexec/java_home `
20609     BOOT_JDK_FOUND=maybe
20610     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home " >&5
20611 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home " >&6;}
20612   fi
20613 
20614 
20615     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20616     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20617       # Do we have a bin/java?
20618       if test ! -x "$BOOT_JDK/bin/java"; then
20619         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20620 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20621         BOOT_JDK_FOUND=no
20622       else
20623         # Do we have a bin/javac?
20624         if test ! -x "$BOOT_JDK/bin/javac"; then
20625           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20626 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20627           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20628 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20629           BOOT_JDK_FOUND=no
20630         else
20631           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20632           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20633 
20634           # Extra M4 quote needed to protect [] in grep expression.
20635           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
20636           if test "x$FOUND_CORRECT_VERSION" = x; then
20637             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20638 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20639             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20640 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20641             BOOT_JDK_FOUND=no
20642           else
20643             # We're done! :-)
20644             BOOT_JDK_FOUND=yes
20645 
20646   # Only process if variable expands to non-empty
20647 
20648   if test "x$BOOT_JDK" != x; then
20649     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20650 
20651   # Input might be given as Windows format, start by converting to
20652   # unix format.
20653   path="$BOOT_JDK"
20654   new_path=`$CYGPATH -u "$path"`
20655 
20656   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20657   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20658   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20659   # "foo.exe" is OK but "foo" is an error.
20660   #
20661   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20662   # It is also a way to make sure we got the proper file name for the real test later on.
20663   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20664   if test "x$test_shortpath" = x; then
20665     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20666 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20667     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20668   fi
20669 
20670   # Call helper function which possibly converts this using DOS-style short mode.
20671   # If so, the updated path is stored in $new_path.
20672 
20673   input_path="$new_path"
20674   # Check if we need to convert this using DOS-style short mode. If the path
20675   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20676   # take no chances and rewrite it.
20677   # Note: m4 eats our [], so we need to use [ and ] instead.
20678   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20679   if test "x$has_forbidden_chars" != x; then
20680     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20681     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20682     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20683     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20684       # Going to short mode and back again did indeed matter. Since short mode is
20685       # case insensitive, let's make it lowercase to improve readability.
20686       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20687       # Now convert it back to Unix-stile (cygpath)
20688       input_path=`$CYGPATH -u "$shortmode_path"`
20689       new_path="$input_path"
20690     fi
20691   fi
20692 
20693   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20694   if test "x$test_cygdrive_prefix" = x; then
20695     # As a simple fix, exclude /usr/bin since it's not a real path.
20696     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20697       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20698       # a path prefixed by /cygdrive for fixpath to work.
20699       new_path="$CYGWIN_ROOT_PATH$input_path"
20700     fi
20701   fi
20702 
20703 
20704   if test "x$path" != "x$new_path"; then
20705     BOOT_JDK="$new_path"
20706     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20707 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20708   fi
20709 
20710     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20711 
20712   path="$BOOT_JDK"
20713   has_colon=`$ECHO $path | $GREP ^.:`
20714   new_path="$path"
20715   if test "x$has_colon" = x; then
20716     # Not in mixed or Windows style, start by that.
20717     new_path=`cmd //c echo $path`
20718   fi
20719 
20720 
20721   input_path="$new_path"
20722   # Check if we need to convert this using DOS-style short mode. If the path
20723   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20724   # take no chances and rewrite it.
20725   # Note: m4 eats our [], so we need to use [ and ] instead.
20726   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20727   if test "x$has_forbidden_chars" != x; then
20728     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20729     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20730   fi
20731 
20732 
20733   windows_path="$new_path"
20734   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20735     unix_path=`$CYGPATH -u "$windows_path"`
20736     new_path="$unix_path"
20737   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20738     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20739     new_path="$unix_path"
20740   fi
20741 
20742   if test "x$path" != "x$new_path"; then
20743     BOOT_JDK="$new_path"
20744     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20745 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20746   fi
20747 
20748   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20749   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20750 
20751     else
20752       # We're on a unix platform. Hooray! :)
20753       path="$BOOT_JDK"
20754       has_space=`$ECHO "$path" | $GREP " "`
20755       if test "x$has_space" != x; then
20756         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20757 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20758         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20759       fi
20760 
20761       # Use eval to expand a potential ~
20762       eval path="$path"
20763       if test ! -f "$path" && test ! -d "$path"; then
20764         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20765       fi
20766 
20767       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20768     fi
20769   fi
20770 
20771             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20772 $as_echo_n "checking for Boot JDK... " >&6; }
20773             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20774 $as_echo "$BOOT_JDK" >&6; }
20775             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20776 $as_echo_n "checking Boot JDK version... " >&6; }
20777             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20778             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20779 $as_echo "$BOOT_JDK_VERSION" >&6; }
20780           fi # end check jdk version
20781         fi # end check javac
20782       fi # end check java
20783     fi # end check boot jdk found
20784   fi
20785 
20786     # If that did not work out (e.g. too old), try explicit versions instead
20787 
20788   if test "x$BOOT_JDK_FOUND" = xno; then
20789     # Now execute the test
20790 
20791   if test -x /usr/libexec/java_home; then
20792     BOOT_JDK=`/usr/libexec/java_home -v 1.9`
20793     BOOT_JDK_FOUND=maybe
20794     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&5
20795 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.9" >&6;}
20796   fi
20797 
20798 
20799     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20800     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20801       # Do we have a bin/java?
20802       if test ! -x "$BOOT_JDK/bin/java"; then
20803         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20804 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20805         BOOT_JDK_FOUND=no
20806       else
20807         # Do we have a bin/javac?
20808         if test ! -x "$BOOT_JDK/bin/javac"; then
20809           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20810 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20811           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20812 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20813           BOOT_JDK_FOUND=no
20814         else
20815           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20816           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
20817 
20818           # Extra M4 quote needed to protect [] in grep expression.
20819           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
20820           if test "x$FOUND_CORRECT_VERSION" = x; then
20821             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
20822 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
20823             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
20824 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
20825             BOOT_JDK_FOUND=no
20826           else
20827             # We're done! :-)
20828             BOOT_JDK_FOUND=yes
20829 
20830   # Only process if variable expands to non-empty
20831 
20832   if test "x$BOOT_JDK" != x; then
20833     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20834 
20835   # Input might be given as Windows format, start by converting to
20836   # unix format.
20837   path="$BOOT_JDK"
20838   new_path=`$CYGPATH -u "$path"`
20839 
20840   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
20841   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
20842   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
20843   # "foo.exe" is OK but "foo" is an error.
20844   #
20845   # This test is therefore slightly more accurate than "test -f" to check for file precense.
20846   # It is also a way to make sure we got the proper file name for the real test later on.
20847   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
20848   if test "x$test_shortpath" = x; then
20849     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20850 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20851     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
20852   fi
20853 
20854   # Call helper function which possibly converts this using DOS-style short mode.
20855   # If so, the updated path is stored in $new_path.
20856 
20857   input_path="$new_path"
20858   # Check if we need to convert this using DOS-style short mode. If the path
20859   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20860   # take no chances and rewrite it.
20861   # Note: m4 eats our [], so we need to use [ and ] instead.
20862   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
20863   if test "x$has_forbidden_chars" != x; then
20864     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20865     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
20866     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
20867     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
20868       # Going to short mode and back again did indeed matter. Since short mode is
20869       # case insensitive, let's make it lowercase to improve readability.
20870       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20871       # Now convert it back to Unix-stile (cygpath)
20872       input_path=`$CYGPATH -u "$shortmode_path"`
20873       new_path="$input_path"
20874     fi
20875   fi
20876 
20877   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
20878   if test "x$test_cygdrive_prefix" = x; then
20879     # As a simple fix, exclude /usr/bin since it's not a real path.
20880     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
20881       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
20882       # a path prefixed by /cygdrive for fixpath to work.
20883       new_path="$CYGWIN_ROOT_PATH$input_path"
20884     fi
20885   fi
20886 
20887 
20888   if test "x$path" != "x$new_path"; then
20889     BOOT_JDK="$new_path"
20890     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20891 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20892   fi
20893 
20894     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20895 
20896   path="$BOOT_JDK"
20897   has_colon=`$ECHO $path | $GREP ^.:`
20898   new_path="$path"
20899   if test "x$has_colon" = x; then
20900     # Not in mixed or Windows style, start by that.
20901     new_path=`cmd //c echo $path`
20902   fi
20903 
20904 
20905   input_path="$new_path"
20906   # Check if we need to convert this using DOS-style short mode. If the path
20907   # contains just simple characters, use it. Otherwise (spaces, weird characters),
20908   # take no chances and rewrite it.
20909   # Note: m4 eats our [], so we need to use [ and ] instead.
20910   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
20911   if test "x$has_forbidden_chars" != x; then
20912     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
20913     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
20914   fi
20915 
20916 
20917   windows_path="$new_path"
20918   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
20919     unix_path=`$CYGPATH -u "$windows_path"`
20920     new_path="$unix_path"
20921   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
20922     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
20923     new_path="$unix_path"
20924   fi
20925 
20926   if test "x$path" != "x$new_path"; then
20927     BOOT_JDK="$new_path"
20928     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
20929 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
20930   fi
20931 
20932   # Save the first 10 bytes of this path to the storage, so fixpath can work.
20933   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
20934 
20935     else
20936       # We're on a unix platform. Hooray! :)
20937       path="$BOOT_JDK"
20938       has_space=`$ECHO "$path" | $GREP " "`
20939       if test "x$has_space" != x; then
20940         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
20941 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
20942         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
20943       fi
20944 
20945       # Use eval to expand a potential ~
20946       eval path="$path"
20947       if test ! -f "$path" && test ! -d "$path"; then
20948         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
20949       fi
20950 
20951       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
20952     fi
20953   fi
20954 
20955             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
20956 $as_echo_n "checking for Boot JDK... " >&6; }
20957             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
20958 $as_echo "$BOOT_JDK" >&6; }
20959             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
20960 $as_echo_n "checking Boot JDK version... " >&6; }
20961             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
20962             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
20963 $as_echo "$BOOT_JDK_VERSION" >&6; }
20964           fi # end check jdk version
20965         fi # end check javac
20966       fi # end check java
20967     fi # end check boot jdk found
20968   fi
20969 
20970 
20971   if test "x$BOOT_JDK_FOUND" = xno; then
20972     # Now execute the test
20973 
20974   if test -x /usr/libexec/java_home; then
20975     BOOT_JDK=`/usr/libexec/java_home -v 1.8`
20976     BOOT_JDK_FOUND=maybe
20977     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&5
20978 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.8" >&6;}
20979   fi
20980 
20981 
20982     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
20983     if test "x$BOOT_JDK_FOUND" = xmaybe; then
20984       # Do we have a bin/java?
20985       if test ! -x "$BOOT_JDK/bin/java"; then
20986         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
20987 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
20988         BOOT_JDK_FOUND=no
20989       else
20990         # Do we have a bin/javac?
20991         if test ! -x "$BOOT_JDK/bin/javac"; then
20992           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
20993 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
20994           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
20995 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
20996           BOOT_JDK_FOUND=no
20997         else
20998           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
20999           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21000 
21001           # Extra M4 quote needed to protect [] in grep expression.
21002           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
21003           if test "x$FOUND_CORRECT_VERSION" = x; then
21004             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21005 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21006             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21007 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21008             BOOT_JDK_FOUND=no
21009           else
21010             # We're done! :-)
21011             BOOT_JDK_FOUND=yes
21012 
21013   # Only process if variable expands to non-empty
21014 
21015   if test "x$BOOT_JDK" != x; then
21016     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21017 
21018   # Input might be given as Windows format, start by converting to
21019   # unix format.
21020   path="$BOOT_JDK"
21021   new_path=`$CYGPATH -u "$path"`
21022 
21023   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21024   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21025   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21026   # "foo.exe" is OK but "foo" is an error.
21027   #
21028   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21029   # It is also a way to make sure we got the proper file name for the real test later on.
21030   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21031   if test "x$test_shortpath" = x; then
21032     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21033 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21034     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21035   fi
21036 
21037   # Call helper function which possibly converts this using DOS-style short mode.
21038   # If so, the updated path is stored in $new_path.
21039 
21040   input_path="$new_path"
21041   # Check if we need to convert this using DOS-style short mode. If the path
21042   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21043   # take no chances and rewrite it.
21044   # Note: m4 eats our [], so we need to use [ and ] instead.
21045   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21046   if test "x$has_forbidden_chars" != x; then
21047     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21048     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21049     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21050     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21051       # Going to short mode and back again did indeed matter. Since short mode is
21052       # case insensitive, let's make it lowercase to improve readability.
21053       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21054       # Now convert it back to Unix-stile (cygpath)
21055       input_path=`$CYGPATH -u "$shortmode_path"`
21056       new_path="$input_path"
21057     fi
21058   fi
21059 
21060   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21061   if test "x$test_cygdrive_prefix" = x; then
21062     # As a simple fix, exclude /usr/bin since it's not a real path.
21063     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21064       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21065       # a path prefixed by /cygdrive for fixpath to work.
21066       new_path="$CYGWIN_ROOT_PATH$input_path"
21067     fi
21068   fi
21069 
21070 
21071   if test "x$path" != "x$new_path"; then
21072     BOOT_JDK="$new_path"
21073     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21074 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21075   fi
21076 
21077     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21078 
21079   path="$BOOT_JDK"
21080   has_colon=`$ECHO $path | $GREP ^.:`
21081   new_path="$path"
21082   if test "x$has_colon" = x; then
21083     # Not in mixed or Windows style, start by that.
21084     new_path=`cmd //c echo $path`
21085   fi
21086 
21087 
21088   input_path="$new_path"
21089   # Check if we need to convert this using DOS-style short mode. If the path
21090   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21091   # take no chances and rewrite it.
21092   # Note: m4 eats our [], so we need to use [ and ] instead.
21093   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21094   if test "x$has_forbidden_chars" != x; then
21095     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21096     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21097   fi
21098 
21099 
21100   windows_path="$new_path"
21101   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21102     unix_path=`$CYGPATH -u "$windows_path"`
21103     new_path="$unix_path"
21104   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21105     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21106     new_path="$unix_path"
21107   fi
21108 
21109   if test "x$path" != "x$new_path"; then
21110     BOOT_JDK="$new_path"
21111     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21112 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21113   fi
21114 
21115   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21116   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21117 
21118     else
21119       # We're on a unix platform. Hooray! :)
21120       path="$BOOT_JDK"
21121       has_space=`$ECHO "$path" | $GREP " "`
21122       if test "x$has_space" != x; then
21123         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21124 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21125         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21126       fi
21127 
21128       # Use eval to expand a potential ~
21129       eval path="$path"
21130       if test ! -f "$path" && test ! -d "$path"; then
21131         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21132       fi
21133 
21134       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21135     fi
21136   fi
21137 
21138             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21139 $as_echo_n "checking for Boot JDK... " >&6; }
21140             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21141 $as_echo "$BOOT_JDK" >&6; }
21142             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21143 $as_echo_n "checking Boot JDK version... " >&6; }
21144             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21145             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21146 $as_echo "$BOOT_JDK_VERSION" >&6; }
21147           fi # end check jdk version
21148         fi # end check javac
21149       fi # end check java
21150     fi # end check boot jdk found
21151   fi
21152 
21153 
21154   if test "x$BOOT_JDK_FOUND" = xno; then
21155     # Now execute the test
21156 
21157   if test -x /usr/libexec/java_home; then
21158     BOOT_JDK=`/usr/libexec/java_home -v 1.7`
21159     BOOT_JDK_FOUND=maybe
21160     { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&5
21161 $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home -v 1.7" >&6;}
21162   fi
21163 
21164 
21165     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21166     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21167       # Do we have a bin/java?
21168       if test ! -x "$BOOT_JDK/bin/java"; then
21169         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21170 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21171         BOOT_JDK_FOUND=no
21172       else
21173         # Do we have a bin/javac?
21174         if test ! -x "$BOOT_JDK/bin/javac"; then
21175           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21176 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21177           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21178 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21179           BOOT_JDK_FOUND=no
21180         else
21181           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21182           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21183 
21184           # Extra M4 quote needed to protect [] in grep expression.
21185           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
21186           if test "x$FOUND_CORRECT_VERSION" = x; then
21187             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21188 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21189             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21190 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21191             BOOT_JDK_FOUND=no
21192           else
21193             # We're done! :-)
21194             BOOT_JDK_FOUND=yes
21195 
21196   # Only process if variable expands to non-empty
21197 
21198   if test "x$BOOT_JDK" != x; then
21199     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21200 
21201   # Input might be given as Windows format, start by converting to
21202   # unix format.
21203   path="$BOOT_JDK"
21204   new_path=`$CYGPATH -u "$path"`
21205 
21206   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21207   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21208   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21209   # "foo.exe" is OK but "foo" is an error.
21210   #
21211   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21212   # It is also a way to make sure we got the proper file name for the real test later on.
21213   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21214   if test "x$test_shortpath" = x; then
21215     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21216 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21217     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21218   fi
21219 
21220   # Call helper function which possibly converts this using DOS-style short mode.
21221   # If so, the updated path is stored in $new_path.
21222 
21223   input_path="$new_path"
21224   # Check if we need to convert this using DOS-style short mode. If the path
21225   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21226   # take no chances and rewrite it.
21227   # Note: m4 eats our [], so we need to use [ and ] instead.
21228   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21229   if test "x$has_forbidden_chars" != x; then
21230     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21231     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21232     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21233     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21234       # Going to short mode and back again did indeed matter. Since short mode is
21235       # case insensitive, let's make it lowercase to improve readability.
21236       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21237       # Now convert it back to Unix-stile (cygpath)
21238       input_path=`$CYGPATH -u "$shortmode_path"`
21239       new_path="$input_path"
21240     fi
21241   fi
21242 
21243   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21244   if test "x$test_cygdrive_prefix" = x; then
21245     # As a simple fix, exclude /usr/bin since it's not a real path.
21246     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21247       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21248       # a path prefixed by /cygdrive for fixpath to work.
21249       new_path="$CYGWIN_ROOT_PATH$input_path"
21250     fi
21251   fi
21252 
21253 
21254   if test "x$path" != "x$new_path"; then
21255     BOOT_JDK="$new_path"
21256     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21257 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21258   fi
21259 
21260     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21261 
21262   path="$BOOT_JDK"
21263   has_colon=`$ECHO $path | $GREP ^.:`
21264   new_path="$path"
21265   if test "x$has_colon" = x; then
21266     # Not in mixed or Windows style, start by that.
21267     new_path=`cmd //c echo $path`
21268   fi
21269 
21270 
21271   input_path="$new_path"
21272   # Check if we need to convert this using DOS-style short mode. If the path
21273   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21274   # take no chances and rewrite it.
21275   # Note: m4 eats our [], so we need to use [ and ] instead.
21276   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21277   if test "x$has_forbidden_chars" != x; then
21278     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21279     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21280   fi
21281 
21282 
21283   windows_path="$new_path"
21284   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21285     unix_path=`$CYGPATH -u "$windows_path"`
21286     new_path="$unix_path"
21287   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21288     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21289     new_path="$unix_path"
21290   fi
21291 
21292   if test "x$path" != "x$new_path"; then
21293     BOOT_JDK="$new_path"
21294     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21295 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21296   fi
21297 
21298   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21299   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21300 
21301     else
21302       # We're on a unix platform. Hooray! :)
21303       path="$BOOT_JDK"
21304       has_space=`$ECHO "$path" | $GREP " "`
21305       if test "x$has_space" != x; then
21306         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21307 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21308         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21309       fi
21310 
21311       # Use eval to expand a potential ~
21312       eval path="$path"
21313       if test ! -f "$path" && test ! -d "$path"; then
21314         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21315       fi
21316 
21317       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21318     fi
21319   fi
21320 
21321             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21322 $as_echo_n "checking for Boot JDK... " >&6; }
21323             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21324 $as_echo "$BOOT_JDK" >&6; }
21325             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21326 $as_echo_n "checking Boot JDK version... " >&6; }
21327             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21328             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21329 $as_echo "$BOOT_JDK_VERSION" >&6; }
21330           fi # end check jdk version
21331         fi # end check javac
21332       fi # end check java
21333     fi # end check boot jdk found
21334   fi
21335 
21336   fi
21337 
21338 
21339     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21340     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21341       # Do we have a bin/java?
21342       if test ! -x "$BOOT_JDK/bin/java"; then
21343         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21344 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21345         BOOT_JDK_FOUND=no
21346       else
21347         # Do we have a bin/javac?
21348         if test ! -x "$BOOT_JDK/bin/javac"; then
21349           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21350 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21351           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21352 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21353           BOOT_JDK_FOUND=no
21354         else
21355           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21356           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21357 
21358           # Extra M4 quote needed to protect [] in grep expression.
21359           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
21360           if test "x$FOUND_CORRECT_VERSION" = x; then
21361             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21362 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21363             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21364 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21365             BOOT_JDK_FOUND=no
21366           else
21367             # We're done! :-)
21368             BOOT_JDK_FOUND=yes
21369 
21370   # Only process if variable expands to non-empty
21371 
21372   if test "x$BOOT_JDK" != x; then
21373     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21374 
21375   # Input might be given as Windows format, start by converting to
21376   # unix format.
21377   path="$BOOT_JDK"
21378   new_path=`$CYGPATH -u "$path"`
21379 
21380   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21381   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21382   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21383   # "foo.exe" is OK but "foo" is an error.
21384   #
21385   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21386   # It is also a way to make sure we got the proper file name for the real test later on.
21387   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21388   if test "x$test_shortpath" = x; then
21389     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21390 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21391     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21392   fi
21393 
21394   # Call helper function which possibly converts this using DOS-style short mode.
21395   # If so, the updated path is stored in $new_path.
21396 
21397   input_path="$new_path"
21398   # Check if we need to convert this using DOS-style short mode. If the path
21399   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21400   # take no chances and rewrite it.
21401   # Note: m4 eats our [], so we need to use [ and ] instead.
21402   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21403   if test "x$has_forbidden_chars" != x; then
21404     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21405     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21406     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21407     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21408       # Going to short mode and back again did indeed matter. Since short mode is
21409       # case insensitive, let's make it lowercase to improve readability.
21410       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21411       # Now convert it back to Unix-stile (cygpath)
21412       input_path=`$CYGPATH -u "$shortmode_path"`
21413       new_path="$input_path"
21414     fi
21415   fi
21416 
21417   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21418   if test "x$test_cygdrive_prefix" = x; then
21419     # As a simple fix, exclude /usr/bin since it's not a real path.
21420     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21421       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21422       # a path prefixed by /cygdrive for fixpath to work.
21423       new_path="$CYGWIN_ROOT_PATH$input_path"
21424     fi
21425   fi
21426 
21427 
21428   if test "x$path" != "x$new_path"; then
21429     BOOT_JDK="$new_path"
21430     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21431 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21432   fi
21433 
21434     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21435 
21436   path="$BOOT_JDK"
21437   has_colon=`$ECHO $path | $GREP ^.:`
21438   new_path="$path"
21439   if test "x$has_colon" = x; then
21440     # Not in mixed or Windows style, start by that.
21441     new_path=`cmd //c echo $path`
21442   fi
21443 
21444 
21445   input_path="$new_path"
21446   # Check if we need to convert this using DOS-style short mode. If the path
21447   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21448   # take no chances and rewrite it.
21449   # Note: m4 eats our [], so we need to use [ and ] instead.
21450   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21451   if test "x$has_forbidden_chars" != x; then
21452     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21453     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21454   fi
21455 
21456 
21457   windows_path="$new_path"
21458   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21459     unix_path=`$CYGPATH -u "$windows_path"`
21460     new_path="$unix_path"
21461   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21462     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21463     new_path="$unix_path"
21464   fi
21465 
21466   if test "x$path" != "x$new_path"; then
21467     BOOT_JDK="$new_path"
21468     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21469 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21470   fi
21471 
21472   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21473   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21474 
21475     else
21476       # We're on a unix platform. Hooray! :)
21477       path="$BOOT_JDK"
21478       has_space=`$ECHO "$path" | $GREP " "`
21479       if test "x$has_space" != x; then
21480         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21481 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21482         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21483       fi
21484 
21485       # Use eval to expand a potential ~
21486       eval path="$path"
21487       if test ! -f "$path" && test ! -d "$path"; then
21488         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21489       fi
21490 
21491       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21492     fi
21493   fi
21494 
21495             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21496 $as_echo_n "checking for Boot JDK... " >&6; }
21497             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21498 $as_echo "$BOOT_JDK" >&6; }
21499             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21500 $as_echo_n "checking Boot JDK version... " >&6; }
21501             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21502             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21503 $as_echo "$BOOT_JDK_VERSION" >&6; }
21504           fi # end check jdk version
21505         fi # end check javac
21506       fi # end check java
21507     fi # end check boot jdk found
21508   fi
21509 
21510 
21511   # Test: Is $JAVA_HOME set?
21512 
21513   if test "x$BOOT_JDK_FOUND" = xno; then
21514     # Now execute the test
21515 
21516   if test "x$JAVA_HOME" != x; then
21517     JAVA_HOME_PROCESSED="$JAVA_HOME"
21518 
21519   # Only process if variable expands to non-empty
21520 
21521   if test "x$JAVA_HOME_PROCESSED" != x; then
21522     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21523 
21524   # Input might be given as Windows format, start by converting to
21525   # unix format.
21526   path="$JAVA_HOME_PROCESSED"
21527   new_path=`$CYGPATH -u "$path"`
21528 
21529   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21530   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21531   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21532   # "foo.exe" is OK but "foo" is an error.
21533   #
21534   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21535   # It is also a way to make sure we got the proper file name for the real test later on.
21536   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21537   if test "x$test_shortpath" = x; then
21538     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
21539 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
21540     as_fn_error $? "Cannot locate the the path of JAVA_HOME_PROCESSED" "$LINENO" 5
21541   fi
21542 
21543   # Call helper function which possibly converts this using DOS-style short mode.
21544   # If so, the updated path is stored in $new_path.
21545 
21546   input_path="$new_path"
21547   # Check if we need to convert this using DOS-style short mode. If the path
21548   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21549   # take no chances and rewrite it.
21550   # Note: m4 eats our [], so we need to use [ and ] instead.
21551   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21552   if test "x$has_forbidden_chars" != x; then
21553     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21554     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21555     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21556     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21557       # Going to short mode and back again did indeed matter. Since short mode is
21558       # case insensitive, let's make it lowercase to improve readability.
21559       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21560       # Now convert it back to Unix-stile (cygpath)
21561       input_path=`$CYGPATH -u "$shortmode_path"`
21562       new_path="$input_path"
21563     fi
21564   fi
21565 
21566   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21567   if test "x$test_cygdrive_prefix" = x; then
21568     # As a simple fix, exclude /usr/bin since it's not a real path.
21569     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21570       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21571       # a path prefixed by /cygdrive for fixpath to work.
21572       new_path="$CYGWIN_ROOT_PATH$input_path"
21573     fi
21574   fi
21575 
21576 
21577   if test "x$path" != "x$new_path"; then
21578     JAVA_HOME_PROCESSED="$new_path"
21579     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
21580 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
21581   fi
21582 
21583     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21584 
21585   path="$JAVA_HOME_PROCESSED"
21586   has_colon=`$ECHO $path | $GREP ^.:`
21587   new_path="$path"
21588   if test "x$has_colon" = x; then
21589     # Not in mixed or Windows style, start by that.
21590     new_path=`cmd //c echo $path`
21591   fi
21592 
21593 
21594   input_path="$new_path"
21595   # Check if we need to convert this using DOS-style short mode. If the path
21596   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21597   # take no chances and rewrite it.
21598   # Note: m4 eats our [], so we need to use [ and ] instead.
21599   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21600   if test "x$has_forbidden_chars" != x; then
21601     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21602     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21603   fi
21604 
21605 
21606   windows_path="$new_path"
21607   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21608     unix_path=`$CYGPATH -u "$windows_path"`
21609     new_path="$unix_path"
21610   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21611     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21612     new_path="$unix_path"
21613   fi
21614 
21615   if test "x$path" != "x$new_path"; then
21616     JAVA_HOME_PROCESSED="$new_path"
21617     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
21618 $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
21619   fi
21620 
21621   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21622   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21623 
21624     else
21625       # We're on a unix platform. Hooray! :)
21626       path="$JAVA_HOME_PROCESSED"
21627       has_space=`$ECHO "$path" | $GREP " "`
21628       if test "x$has_space" != x; then
21629         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
21630 $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
21631         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21632       fi
21633 
21634       # Use eval to expand a potential ~
21635       eval path="$path"
21636       if test ! -f "$path" && test ! -d "$path"; then
21637         as_fn_error $? "The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is not found." "$LINENO" 5
21638       fi
21639 
21640       JAVA_HOME_PROCESSED="`cd "$path"; $THEPWDCMD -L`"
21641     fi
21642   fi
21643 
21644     if test ! -d "$JAVA_HOME_PROCESSED"; then
21645       { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
21646 $as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
21647     else
21648       # Aha, the user has set a JAVA_HOME
21649       # let us use that as the Boot JDK.
21650       BOOT_JDK="$JAVA_HOME_PROCESSED"
21651       BOOT_JDK_FOUND=maybe
21652       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using JAVA_HOME" >&5
21653 $as_echo "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
21654     fi
21655   fi
21656 
21657 
21658     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21659     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21660       # Do we have a bin/java?
21661       if test ! -x "$BOOT_JDK/bin/java"; then
21662         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21663 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21664         BOOT_JDK_FOUND=no
21665       else
21666         # Do we have a bin/javac?
21667         if test ! -x "$BOOT_JDK/bin/javac"; then
21668           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21669 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21670           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21671 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21672           BOOT_JDK_FOUND=no
21673         else
21674           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
21675           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
21676 
21677           # Extra M4 quote needed to protect [] in grep expression.
21678           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
21679           if test "x$FOUND_CORRECT_VERSION" = x; then
21680             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
21681 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
21682             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
21683 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
21684             BOOT_JDK_FOUND=no
21685           else
21686             # We're done! :-)
21687             BOOT_JDK_FOUND=yes
21688 
21689   # Only process if variable expands to non-empty
21690 
21691   if test "x$BOOT_JDK" != x; then
21692     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21693 
21694   # Input might be given as Windows format, start by converting to
21695   # unix format.
21696   path="$BOOT_JDK"
21697   new_path=`$CYGPATH -u "$path"`
21698 
21699   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
21700   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
21701   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
21702   # "foo.exe" is OK but "foo" is an error.
21703   #
21704   # This test is therefore slightly more accurate than "test -f" to check for file precense.
21705   # It is also a way to make sure we got the proper file name for the real test later on.
21706   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
21707   if test "x$test_shortpath" = x; then
21708     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21709 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21710     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
21711   fi
21712 
21713   # Call helper function which possibly converts this using DOS-style short mode.
21714   # If so, the updated path is stored in $new_path.
21715 
21716   input_path="$new_path"
21717   # Check if we need to convert this using DOS-style short mode. If the path
21718   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21719   # take no chances and rewrite it.
21720   # Note: m4 eats our [], so we need to use [ and ] instead.
21721   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
21722   if test "x$has_forbidden_chars" != x; then
21723     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21724     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
21725     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
21726     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
21727       # Going to short mode and back again did indeed matter. Since short mode is
21728       # case insensitive, let's make it lowercase to improve readability.
21729       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21730       # Now convert it back to Unix-stile (cygpath)
21731       input_path=`$CYGPATH -u "$shortmode_path"`
21732       new_path="$input_path"
21733     fi
21734   fi
21735 
21736   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
21737   if test "x$test_cygdrive_prefix" = x; then
21738     # As a simple fix, exclude /usr/bin since it's not a real path.
21739     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
21740       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
21741       # a path prefixed by /cygdrive for fixpath to work.
21742       new_path="$CYGWIN_ROOT_PATH$input_path"
21743     fi
21744   fi
21745 
21746 
21747   if test "x$path" != "x$new_path"; then
21748     BOOT_JDK="$new_path"
21749     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21750 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21751   fi
21752 
21753     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21754 
21755   path="$BOOT_JDK"
21756   has_colon=`$ECHO $path | $GREP ^.:`
21757   new_path="$path"
21758   if test "x$has_colon" = x; then
21759     # Not in mixed or Windows style, start by that.
21760     new_path=`cmd //c echo $path`
21761   fi
21762 
21763 
21764   input_path="$new_path"
21765   # Check if we need to convert this using DOS-style short mode. If the path
21766   # contains just simple characters, use it. Otherwise (spaces, weird characters),
21767   # take no chances and rewrite it.
21768   # Note: m4 eats our [], so we need to use [ and ] instead.
21769   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
21770   if test "x$has_forbidden_chars" != x; then
21771     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
21772     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
21773   fi
21774 
21775 
21776   windows_path="$new_path"
21777   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
21778     unix_path=`$CYGPATH -u "$windows_path"`
21779     new_path="$unix_path"
21780   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
21781     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
21782     new_path="$unix_path"
21783   fi
21784 
21785   if test "x$path" != "x$new_path"; then
21786     BOOT_JDK="$new_path"
21787     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
21788 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
21789   fi
21790 
21791   # Save the first 10 bytes of this path to the storage, so fixpath can work.
21792   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
21793 
21794     else
21795       # We're on a unix platform. Hooray! :)
21796       path="$BOOT_JDK"
21797       has_space=`$ECHO "$path" | $GREP " "`
21798       if test "x$has_space" != x; then
21799         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
21800 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
21801         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
21802       fi
21803 
21804       # Use eval to expand a potential ~
21805       eval path="$path"
21806       if test ! -f "$path" && test ! -d "$path"; then
21807         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
21808       fi
21809 
21810       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
21811     fi
21812   fi
21813 
21814             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
21815 $as_echo_n "checking for Boot JDK... " >&6; }
21816             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
21817 $as_echo "$BOOT_JDK" >&6; }
21818             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
21819 $as_echo_n "checking Boot JDK version... " >&6; }
21820             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
21821             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
21822 $as_echo "$BOOT_JDK_VERSION" >&6; }
21823           fi # end check jdk version
21824         fi # end check javac
21825       fi # end check java
21826     fi # end check boot jdk found
21827   fi
21828 
21829 
21830   # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
21831 
21832   if test "x$BOOT_JDK_FOUND" = xno; then
21833     # Now execute the test
21834 
21835   # Extract the first word of "javac", so it can be a program name with args.
21836 set dummy javac; ac_word=$2
21837 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21838 $as_echo_n "checking for $ac_word... " >&6; }
21839 if ${ac_cv_path_JAVAC_CHECK+:} false; then :
21840   $as_echo_n "(cached) " >&6
21841 else
21842   case $JAVAC_CHECK in
21843   [\\/]* | ?:[\\/]*)
21844   ac_cv_path_JAVAC_CHECK="$JAVAC_CHECK" # Let the user override the test with a path.
21845   ;;
21846   *)
21847   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21848 for as_dir in $PATH
21849 do
21850   IFS=$as_save_IFS
21851   test -z "$as_dir" && as_dir=.
21852     for ac_exec_ext in '' $ac_executable_extensions; do
21853   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21854     ac_cv_path_JAVAC_CHECK="$as_dir/$ac_word$ac_exec_ext"
21855     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21856     break 2
21857   fi
21858 done
21859   done
21860 IFS=$as_save_IFS
21861 
21862   ;;
21863 esac
21864 fi
21865 JAVAC_CHECK=$ac_cv_path_JAVAC_CHECK
21866 if test -n "$JAVAC_CHECK"; then
21867   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5
21868 $as_echo "$JAVAC_CHECK" >&6; }
21869 else
21870   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21871 $as_echo "no" >&6; }
21872 fi
21873 
21874 
21875   # Extract the first word of "java", so it can be a program name with args.
21876 set dummy java; ac_word=$2
21877 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
21878 $as_echo_n "checking for $ac_word... " >&6; }
21879 if ${ac_cv_path_JAVA_CHECK+:} false; then :
21880   $as_echo_n "(cached) " >&6
21881 else
21882   case $JAVA_CHECK in
21883   [\\/]* | ?:[\\/]*)
21884   ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path.
21885   ;;
21886   *)
21887   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21888 for as_dir in $PATH
21889 do
21890   IFS=$as_save_IFS
21891   test -z "$as_dir" && as_dir=.
21892     for ac_exec_ext in '' $ac_executable_extensions; do
21893   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
21894     ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext"
21895     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
21896     break 2
21897   fi
21898 done
21899   done
21900 IFS=$as_save_IFS
21901 
21902   ;;
21903 esac
21904 fi
21905 JAVA_CHECK=$ac_cv_path_JAVA_CHECK
21906 if test -n "$JAVA_CHECK"; then
21907   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5
21908 $as_echo "$JAVA_CHECK" >&6; }
21909 else
21910   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
21911 $as_echo "no" >&6; }
21912 fi
21913 
21914 
21915   BINARY="$JAVAC_CHECK"
21916   if test "x$JAVAC_CHECK" = x; then
21917     BINARY="$JAVA_CHECK"
21918   fi
21919   if test "x$BINARY" != x; then
21920     # So there is a java(c) binary, it might be part of a JDK.
21921     # Lets find the JDK/JRE directory by following symbolic links.
21922     # Linux/GNU systems often have links from /usr/bin/java to
21923     # /etc/alternatives/java to the real JDK binary.
21924 
21925   if test "x$OPENJDK_BUILD_OS" != xwindows; then
21926     # Follow a chain of symbolic links. Use readlink
21927     # where it exists, else fall back to horribly
21928     # complicated shell code.
21929     if test "x$READLINK_TESTED" != yes; then
21930       # On MacOSX there is a readlink tool with a different
21931       # purpose than the GNU readlink tool. Check the found readlink.
21932       ISGNU=`$READLINK --version 2>&1 | $GREP GNU`
21933       if test "x$ISGNU" = x; then
21934         # A readlink that we do not know how to use.
21935         # Are there other non-GNU readlinks out there?
21936         READLINK_TESTED=yes
21937         READLINK=
21938       fi
21939     fi
21940 
21941     if test "x$READLINK" != x; then
21942       BINARY=`$READLINK -f $BINARY`
21943     else
21944       # Save the current directory for restoring afterwards
21945       STARTDIR=$PWD
21946       COUNTER=0
21947       sym_link_dir=`$DIRNAME $BINARY`
21948       sym_link_file=`$BASENAME $BINARY`
21949       cd $sym_link_dir
21950       # Use -P flag to resolve symlinks in directories.
21951       cd `$THEPWDCMD -P`
21952       sym_link_dir=`$THEPWDCMD -P`
21953       # Resolve file symlinks
21954       while test $COUNTER -lt 20; do
21955         ISLINK=`$LS -l $sym_link_dir/$sym_link_file | $GREP '\->' | $SED -e 's/.*-> \(.*\)/\1/'`
21956         if test "x$ISLINK" == x; then
21957           # This is not a symbolic link! We are done!
21958           break
21959         fi
21960         # Again resolve directory symlinks since the target of the just found
21961         # link could be in a different directory
21962         cd `$DIRNAME $ISLINK`
21963         sym_link_dir=`$THEPWDCMD -P`
21964         sym_link_file=`$BASENAME $ISLINK`
21965         let COUNTER=COUNTER+1
21966       done
21967       cd $STARTDIR
21968       BINARY=$sym_link_dir/$sym_link_file
21969     fi
21970   fi
21971 
21972     BOOT_JDK=`dirname "$BINARY"`
21973     BOOT_JDK=`cd "$BOOT_JDK/.."; pwd`
21974     if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then
21975       # Looks like we found ourselves an JDK
21976       BOOT_JDK_FOUND=maybe
21977       { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using java(c) in PATH" >&5
21978 $as_echo "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
21979     fi
21980   fi
21981 
21982 
21983     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
21984     if test "x$BOOT_JDK_FOUND" = xmaybe; then
21985       # Do we have a bin/java?
21986       if test ! -x "$BOOT_JDK/bin/java"; then
21987         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
21988 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
21989         BOOT_JDK_FOUND=no
21990       else
21991         # Do we have a bin/javac?
21992         if test ! -x "$BOOT_JDK/bin/javac"; then
21993           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
21994 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
21995           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
21996 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
21997           BOOT_JDK_FOUND=no
21998         else
21999           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22000           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22001 
22002           # Extra M4 quote needed to protect [] in grep expression.
22003           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22004           if test "x$FOUND_CORRECT_VERSION" = x; then
22005             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22006 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22007             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22008 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22009             BOOT_JDK_FOUND=no
22010           else
22011             # We're done! :-)
22012             BOOT_JDK_FOUND=yes
22013 
22014   # Only process if variable expands to non-empty
22015 
22016   if test "x$BOOT_JDK" != x; then
22017     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22018 
22019   # Input might be given as Windows format, start by converting to
22020   # unix format.
22021   path="$BOOT_JDK"
22022   new_path=`$CYGPATH -u "$path"`
22023 
22024   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22025   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22026   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22027   # "foo.exe" is OK but "foo" is an error.
22028   #
22029   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22030   # It is also a way to make sure we got the proper file name for the real test later on.
22031   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22032   if test "x$test_shortpath" = x; then
22033     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22034 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22035     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22036   fi
22037 
22038   # Call helper function which possibly converts this using DOS-style short mode.
22039   # If so, the updated path is stored in $new_path.
22040 
22041   input_path="$new_path"
22042   # Check if we need to convert this using DOS-style short mode. If the path
22043   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22044   # take no chances and rewrite it.
22045   # Note: m4 eats our [], so we need to use [ and ] instead.
22046   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22047   if test "x$has_forbidden_chars" != x; then
22048     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22049     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22050     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22051     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22052       # Going to short mode and back again did indeed matter. Since short mode is
22053       # case insensitive, let's make it lowercase to improve readability.
22054       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22055       # Now convert it back to Unix-stile (cygpath)
22056       input_path=`$CYGPATH -u "$shortmode_path"`
22057       new_path="$input_path"
22058     fi
22059   fi
22060 
22061   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22062   if test "x$test_cygdrive_prefix" = x; then
22063     # As a simple fix, exclude /usr/bin since it's not a real path.
22064     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22065       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22066       # a path prefixed by /cygdrive for fixpath to work.
22067       new_path="$CYGWIN_ROOT_PATH$input_path"
22068     fi
22069   fi
22070 
22071 
22072   if test "x$path" != "x$new_path"; then
22073     BOOT_JDK="$new_path"
22074     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22075 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22076   fi
22077 
22078     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22079 
22080   path="$BOOT_JDK"
22081   has_colon=`$ECHO $path | $GREP ^.:`
22082   new_path="$path"
22083   if test "x$has_colon" = x; then
22084     # Not in mixed or Windows style, start by that.
22085     new_path=`cmd //c echo $path`
22086   fi
22087 
22088 
22089   input_path="$new_path"
22090   # Check if we need to convert this using DOS-style short mode. If the path
22091   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22092   # take no chances and rewrite it.
22093   # Note: m4 eats our [], so we need to use [ and ] instead.
22094   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22095   if test "x$has_forbidden_chars" != x; then
22096     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22097     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22098   fi
22099 
22100 
22101   windows_path="$new_path"
22102   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22103     unix_path=`$CYGPATH -u "$windows_path"`
22104     new_path="$unix_path"
22105   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22106     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22107     new_path="$unix_path"
22108   fi
22109 
22110   if test "x$path" != "x$new_path"; then
22111     BOOT_JDK="$new_path"
22112     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22113 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22114   fi
22115 
22116   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22117   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22118 
22119     else
22120       # We're on a unix platform. Hooray! :)
22121       path="$BOOT_JDK"
22122       has_space=`$ECHO "$path" | $GREP " "`
22123       if test "x$has_space" != x; then
22124         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22125 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22126         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22127       fi
22128 
22129       # Use eval to expand a potential ~
22130       eval path="$path"
22131       if test ! -f "$path" && test ! -d "$path"; then
22132         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22133       fi
22134 
22135       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22136     fi
22137   fi
22138 
22139             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22140 $as_echo_n "checking for Boot JDK... " >&6; }
22141             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22142 $as_echo "$BOOT_JDK" >&6; }
22143             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22144 $as_echo_n "checking Boot JDK version... " >&6; }
22145             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22146             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22147 $as_echo "$BOOT_JDK_VERSION" >&6; }
22148           fi # end check jdk version
22149         fi # end check javac
22150       fi # end check java
22151     fi # end check boot jdk found
22152   fi
22153 
22154 
22155   # Test: Is there a JDK installed in default, well-known locations?
22156 
22157   if test "x$BOOT_JDK_FOUND" = xno; then
22158     # Now execute the test
22159 
22160   if test "x$OPENJDK_TARGET_OS" = xwindows; then
22161 
22162   if test "x$BOOT_JDK_FOUND" = xno; then
22163     # Now execute the test
22164 
22165   if test "x$ProgramW6432" != x; then
22166     VIRTUAL_DIR="$ProgramW6432/Java"
22167 
22168   windows_path="$VIRTUAL_DIR"
22169   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22170     unix_path=`$CYGPATH -u "$windows_path"`
22171     VIRTUAL_DIR="$unix_path"
22172   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22173     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22174     VIRTUAL_DIR="$unix_path"
22175   fi
22176 
22177 
22178   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22179   BOOT_JDK_SUFFIX=""
22180   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22181   if test "x$ALL_JDKS_FOUND" != x; then
22182     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22183 
22184   if test "x$BOOT_JDK_FOUND" = xno; then
22185     # Now execute the test
22186 
22187         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22188         if test -d "$BOOT_JDK"; then
22189           BOOT_JDK_FOUND=maybe
22190           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22191 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22192         fi
22193 
22194 
22195     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22196     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22197       # Do we have a bin/java?
22198       if test ! -x "$BOOT_JDK/bin/java"; then
22199         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22200 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22201         BOOT_JDK_FOUND=no
22202       else
22203         # Do we have a bin/javac?
22204         if test ! -x "$BOOT_JDK/bin/javac"; then
22205           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22206 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22207           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22208 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22209           BOOT_JDK_FOUND=no
22210         else
22211           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22212           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22213 
22214           # Extra M4 quote needed to protect [] in grep expression.
22215           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22216           if test "x$FOUND_CORRECT_VERSION" = x; then
22217             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22218 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22219             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22220 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22221             BOOT_JDK_FOUND=no
22222           else
22223             # We're done! :-)
22224             BOOT_JDK_FOUND=yes
22225 
22226   # Only process if variable expands to non-empty
22227 
22228   if test "x$BOOT_JDK" != x; then
22229     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22230 
22231   # Input might be given as Windows format, start by converting to
22232   # unix format.
22233   path="$BOOT_JDK"
22234   new_path=`$CYGPATH -u "$path"`
22235 
22236   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22237   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22238   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22239   # "foo.exe" is OK but "foo" is an error.
22240   #
22241   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22242   # It is also a way to make sure we got the proper file name for the real test later on.
22243   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22244   if test "x$test_shortpath" = x; then
22245     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22246 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22247     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22248   fi
22249 
22250   # Call helper function which possibly converts this using DOS-style short mode.
22251   # If so, the updated path is stored in $new_path.
22252 
22253   input_path="$new_path"
22254   # Check if we need to convert this using DOS-style short mode. If the path
22255   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22256   # take no chances and rewrite it.
22257   # Note: m4 eats our [], so we need to use [ and ] instead.
22258   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22259   if test "x$has_forbidden_chars" != x; then
22260     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22261     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22262     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22263     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22264       # Going to short mode and back again did indeed matter. Since short mode is
22265       # case insensitive, let's make it lowercase to improve readability.
22266       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22267       # Now convert it back to Unix-stile (cygpath)
22268       input_path=`$CYGPATH -u "$shortmode_path"`
22269       new_path="$input_path"
22270     fi
22271   fi
22272 
22273   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22274   if test "x$test_cygdrive_prefix" = x; then
22275     # As a simple fix, exclude /usr/bin since it's not a real path.
22276     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22277       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22278       # a path prefixed by /cygdrive for fixpath to work.
22279       new_path="$CYGWIN_ROOT_PATH$input_path"
22280     fi
22281   fi
22282 
22283 
22284   if test "x$path" != "x$new_path"; then
22285     BOOT_JDK="$new_path"
22286     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22287 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22288   fi
22289 
22290     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22291 
22292   path="$BOOT_JDK"
22293   has_colon=`$ECHO $path | $GREP ^.:`
22294   new_path="$path"
22295   if test "x$has_colon" = x; then
22296     # Not in mixed or Windows style, start by that.
22297     new_path=`cmd //c echo $path`
22298   fi
22299 
22300 
22301   input_path="$new_path"
22302   # Check if we need to convert this using DOS-style short mode. If the path
22303   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22304   # take no chances and rewrite it.
22305   # Note: m4 eats our [], so we need to use [ and ] instead.
22306   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22307   if test "x$has_forbidden_chars" != x; then
22308     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22309     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22310   fi
22311 
22312 
22313   windows_path="$new_path"
22314   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22315     unix_path=`$CYGPATH -u "$windows_path"`
22316     new_path="$unix_path"
22317   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22318     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22319     new_path="$unix_path"
22320   fi
22321 
22322   if test "x$path" != "x$new_path"; then
22323     BOOT_JDK="$new_path"
22324     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22325 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22326   fi
22327 
22328   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22329   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22330 
22331     else
22332       # We're on a unix platform. Hooray! :)
22333       path="$BOOT_JDK"
22334       has_space=`$ECHO "$path" | $GREP " "`
22335       if test "x$has_space" != x; then
22336         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22337 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22338         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22339       fi
22340 
22341       # Use eval to expand a potential ~
22342       eval path="$path"
22343       if test ! -f "$path" && test ! -d "$path"; then
22344         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22345       fi
22346 
22347       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22348     fi
22349   fi
22350 
22351             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22352 $as_echo_n "checking for Boot JDK... " >&6; }
22353             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22354 $as_echo "$BOOT_JDK" >&6; }
22355             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22356 $as_echo_n "checking Boot JDK version... " >&6; }
22357             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22358             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22359 $as_echo "$BOOT_JDK_VERSION" >&6; }
22360           fi # end check jdk version
22361         fi # end check javac
22362       fi # end check java
22363     fi # end check boot jdk found
22364   fi
22365 
22366     done
22367   fi
22368 
22369   fi
22370 
22371 
22372     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22373     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22374       # Do we have a bin/java?
22375       if test ! -x "$BOOT_JDK/bin/java"; then
22376         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22377 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22378         BOOT_JDK_FOUND=no
22379       else
22380         # Do we have a bin/javac?
22381         if test ! -x "$BOOT_JDK/bin/javac"; then
22382           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22383 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22384           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22385 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22386           BOOT_JDK_FOUND=no
22387         else
22388           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22389           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22390 
22391           # Extra M4 quote needed to protect [] in grep expression.
22392           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22393           if test "x$FOUND_CORRECT_VERSION" = x; then
22394             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22395 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22396             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22397 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22398             BOOT_JDK_FOUND=no
22399           else
22400             # We're done! :-)
22401             BOOT_JDK_FOUND=yes
22402 
22403   # Only process if variable expands to non-empty
22404 
22405   if test "x$BOOT_JDK" != x; then
22406     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22407 
22408   # Input might be given as Windows format, start by converting to
22409   # unix format.
22410   path="$BOOT_JDK"
22411   new_path=`$CYGPATH -u "$path"`
22412 
22413   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22414   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22415   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22416   # "foo.exe" is OK but "foo" is an error.
22417   #
22418   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22419   # It is also a way to make sure we got the proper file name for the real test later on.
22420   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22421   if test "x$test_shortpath" = x; then
22422     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22423 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22424     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22425   fi
22426 
22427   # Call helper function which possibly converts this using DOS-style short mode.
22428   # If so, the updated path is stored in $new_path.
22429 
22430   input_path="$new_path"
22431   # Check if we need to convert this using DOS-style short mode. If the path
22432   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22433   # take no chances and rewrite it.
22434   # Note: m4 eats our [], so we need to use [ and ] instead.
22435   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22436   if test "x$has_forbidden_chars" != x; then
22437     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22438     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22439     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22440     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22441       # Going to short mode and back again did indeed matter. Since short mode is
22442       # case insensitive, let's make it lowercase to improve readability.
22443       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22444       # Now convert it back to Unix-stile (cygpath)
22445       input_path=`$CYGPATH -u "$shortmode_path"`
22446       new_path="$input_path"
22447     fi
22448   fi
22449 
22450   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22451   if test "x$test_cygdrive_prefix" = x; then
22452     # As a simple fix, exclude /usr/bin since it's not a real path.
22453     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22454       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22455       # a path prefixed by /cygdrive for fixpath to work.
22456       new_path="$CYGWIN_ROOT_PATH$input_path"
22457     fi
22458   fi
22459 
22460 
22461   if test "x$path" != "x$new_path"; then
22462     BOOT_JDK="$new_path"
22463     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22464 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22465   fi
22466 
22467     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22468 
22469   path="$BOOT_JDK"
22470   has_colon=`$ECHO $path | $GREP ^.:`
22471   new_path="$path"
22472   if test "x$has_colon" = x; then
22473     # Not in mixed or Windows style, start by that.
22474     new_path=`cmd //c echo $path`
22475   fi
22476 
22477 
22478   input_path="$new_path"
22479   # Check if we need to convert this using DOS-style short mode. If the path
22480   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22481   # take no chances and rewrite it.
22482   # Note: m4 eats our [], so we need to use [ and ] instead.
22483   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22484   if test "x$has_forbidden_chars" != x; then
22485     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22486     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22487   fi
22488 
22489 
22490   windows_path="$new_path"
22491   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22492     unix_path=`$CYGPATH -u "$windows_path"`
22493     new_path="$unix_path"
22494   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22495     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22496     new_path="$unix_path"
22497   fi
22498 
22499   if test "x$path" != "x$new_path"; then
22500     BOOT_JDK="$new_path"
22501     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22502 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22503   fi
22504 
22505   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22506   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22507 
22508     else
22509       # We're on a unix platform. Hooray! :)
22510       path="$BOOT_JDK"
22511       has_space=`$ECHO "$path" | $GREP " "`
22512       if test "x$has_space" != x; then
22513         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22514 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22515         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22516       fi
22517 
22518       # Use eval to expand a potential ~
22519       eval path="$path"
22520       if test ! -f "$path" && test ! -d "$path"; then
22521         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22522       fi
22523 
22524       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22525     fi
22526   fi
22527 
22528             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22529 $as_echo_n "checking for Boot JDK... " >&6; }
22530             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22531 $as_echo "$BOOT_JDK" >&6; }
22532             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22533 $as_echo_n "checking Boot JDK version... " >&6; }
22534             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22535             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22536 $as_echo "$BOOT_JDK_VERSION" >&6; }
22537           fi # end check jdk version
22538         fi # end check javac
22539       fi # end check java
22540     fi # end check boot jdk found
22541   fi
22542 
22543 
22544   if test "x$BOOT_JDK_FOUND" = xno; then
22545     # Now execute the test
22546 
22547   if test "x$PROGRAMW6432" != x; then
22548     VIRTUAL_DIR="$PROGRAMW6432/Java"
22549 
22550   windows_path="$VIRTUAL_DIR"
22551   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22552     unix_path=`$CYGPATH -u "$windows_path"`
22553     VIRTUAL_DIR="$unix_path"
22554   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22555     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22556     VIRTUAL_DIR="$unix_path"
22557   fi
22558 
22559 
22560   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22561   BOOT_JDK_SUFFIX=""
22562   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22563   if test "x$ALL_JDKS_FOUND" != x; then
22564     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22565 
22566   if test "x$BOOT_JDK_FOUND" = xno; then
22567     # Now execute the test
22568 
22569         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22570         if test -d "$BOOT_JDK"; then
22571           BOOT_JDK_FOUND=maybe
22572           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22573 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22574         fi
22575 
22576 
22577     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22578     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22579       # Do we have a bin/java?
22580       if test ! -x "$BOOT_JDK/bin/java"; then
22581         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22582 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22583         BOOT_JDK_FOUND=no
22584       else
22585         # Do we have a bin/javac?
22586         if test ! -x "$BOOT_JDK/bin/javac"; then
22587           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22588 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22589           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22590 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22591           BOOT_JDK_FOUND=no
22592         else
22593           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22594           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22595 
22596           # Extra M4 quote needed to protect [] in grep expression.
22597           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22598           if test "x$FOUND_CORRECT_VERSION" = x; then
22599             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22600 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22601             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22602 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22603             BOOT_JDK_FOUND=no
22604           else
22605             # We're done! :-)
22606             BOOT_JDK_FOUND=yes
22607 
22608   # Only process if variable expands to non-empty
22609 
22610   if test "x$BOOT_JDK" != x; then
22611     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22612 
22613   # Input might be given as Windows format, start by converting to
22614   # unix format.
22615   path="$BOOT_JDK"
22616   new_path=`$CYGPATH -u "$path"`
22617 
22618   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22619   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22620   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22621   # "foo.exe" is OK but "foo" is an error.
22622   #
22623   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22624   # It is also a way to make sure we got the proper file name for the real test later on.
22625   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22626   if test "x$test_shortpath" = x; then
22627     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22628 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22629     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22630   fi
22631 
22632   # Call helper function which possibly converts this using DOS-style short mode.
22633   # If so, the updated path is stored in $new_path.
22634 
22635   input_path="$new_path"
22636   # Check if we need to convert this using DOS-style short mode. If the path
22637   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22638   # take no chances and rewrite it.
22639   # Note: m4 eats our [], so we need to use [ and ] instead.
22640   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22641   if test "x$has_forbidden_chars" != x; then
22642     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22643     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22644     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22645     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22646       # Going to short mode and back again did indeed matter. Since short mode is
22647       # case insensitive, let's make it lowercase to improve readability.
22648       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22649       # Now convert it back to Unix-stile (cygpath)
22650       input_path=`$CYGPATH -u "$shortmode_path"`
22651       new_path="$input_path"
22652     fi
22653   fi
22654 
22655   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22656   if test "x$test_cygdrive_prefix" = x; then
22657     # As a simple fix, exclude /usr/bin since it's not a real path.
22658     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22659       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22660       # a path prefixed by /cygdrive for fixpath to work.
22661       new_path="$CYGWIN_ROOT_PATH$input_path"
22662     fi
22663   fi
22664 
22665 
22666   if test "x$path" != "x$new_path"; then
22667     BOOT_JDK="$new_path"
22668     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22669 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22670   fi
22671 
22672     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22673 
22674   path="$BOOT_JDK"
22675   has_colon=`$ECHO $path | $GREP ^.:`
22676   new_path="$path"
22677   if test "x$has_colon" = x; then
22678     # Not in mixed or Windows style, start by that.
22679     new_path=`cmd //c echo $path`
22680   fi
22681 
22682 
22683   input_path="$new_path"
22684   # Check if we need to convert this using DOS-style short mode. If the path
22685   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22686   # take no chances and rewrite it.
22687   # Note: m4 eats our [], so we need to use [ and ] instead.
22688   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22689   if test "x$has_forbidden_chars" != x; then
22690     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22691     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22692   fi
22693 
22694 
22695   windows_path="$new_path"
22696   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22697     unix_path=`$CYGPATH -u "$windows_path"`
22698     new_path="$unix_path"
22699   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22700     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22701     new_path="$unix_path"
22702   fi
22703 
22704   if test "x$path" != "x$new_path"; then
22705     BOOT_JDK="$new_path"
22706     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22707 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22708   fi
22709 
22710   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22711   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22712 
22713     else
22714       # We're on a unix platform. Hooray! :)
22715       path="$BOOT_JDK"
22716       has_space=`$ECHO "$path" | $GREP " "`
22717       if test "x$has_space" != x; then
22718         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22719 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22720         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22721       fi
22722 
22723       # Use eval to expand a potential ~
22724       eval path="$path"
22725       if test ! -f "$path" && test ! -d "$path"; then
22726         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22727       fi
22728 
22729       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22730     fi
22731   fi
22732 
22733             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22734 $as_echo_n "checking for Boot JDK... " >&6; }
22735             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22736 $as_echo "$BOOT_JDK" >&6; }
22737             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22738 $as_echo_n "checking Boot JDK version... " >&6; }
22739             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22740             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22741 $as_echo "$BOOT_JDK_VERSION" >&6; }
22742           fi # end check jdk version
22743         fi # end check javac
22744       fi # end check java
22745     fi # end check boot jdk found
22746   fi
22747 
22748     done
22749   fi
22750 
22751   fi
22752 
22753 
22754     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22755     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22756       # Do we have a bin/java?
22757       if test ! -x "$BOOT_JDK/bin/java"; then
22758         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22759 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22760         BOOT_JDK_FOUND=no
22761       else
22762         # Do we have a bin/javac?
22763         if test ! -x "$BOOT_JDK/bin/javac"; then
22764           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22765 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22766           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22767 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22768           BOOT_JDK_FOUND=no
22769         else
22770           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22771           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22772 
22773           # Extra M4 quote needed to protect [] in grep expression.
22774           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22775           if test "x$FOUND_CORRECT_VERSION" = x; then
22776             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22777 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22778             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22779 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22780             BOOT_JDK_FOUND=no
22781           else
22782             # We're done! :-)
22783             BOOT_JDK_FOUND=yes
22784 
22785   # Only process if variable expands to non-empty
22786 
22787   if test "x$BOOT_JDK" != x; then
22788     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22789 
22790   # Input might be given as Windows format, start by converting to
22791   # unix format.
22792   path="$BOOT_JDK"
22793   new_path=`$CYGPATH -u "$path"`
22794 
22795   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
22796   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
22797   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
22798   # "foo.exe" is OK but "foo" is an error.
22799   #
22800   # This test is therefore slightly more accurate than "test -f" to check for file precense.
22801   # It is also a way to make sure we got the proper file name for the real test later on.
22802   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
22803   if test "x$test_shortpath" = x; then
22804     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22805 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22806     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
22807   fi
22808 
22809   # Call helper function which possibly converts this using DOS-style short mode.
22810   # If so, the updated path is stored in $new_path.
22811 
22812   input_path="$new_path"
22813   # Check if we need to convert this using DOS-style short mode. If the path
22814   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22815   # take no chances and rewrite it.
22816   # Note: m4 eats our [], so we need to use [ and ] instead.
22817   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
22818   if test "x$has_forbidden_chars" != x; then
22819     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22820     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
22821     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
22822     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
22823       # Going to short mode and back again did indeed matter. Since short mode is
22824       # case insensitive, let's make it lowercase to improve readability.
22825       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22826       # Now convert it back to Unix-stile (cygpath)
22827       input_path=`$CYGPATH -u "$shortmode_path"`
22828       new_path="$input_path"
22829     fi
22830   fi
22831 
22832   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
22833   if test "x$test_cygdrive_prefix" = x; then
22834     # As a simple fix, exclude /usr/bin since it's not a real path.
22835     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
22836       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
22837       # a path prefixed by /cygdrive for fixpath to work.
22838       new_path="$CYGWIN_ROOT_PATH$input_path"
22839     fi
22840   fi
22841 
22842 
22843   if test "x$path" != "x$new_path"; then
22844     BOOT_JDK="$new_path"
22845     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22846 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22847   fi
22848 
22849     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22850 
22851   path="$BOOT_JDK"
22852   has_colon=`$ECHO $path | $GREP ^.:`
22853   new_path="$path"
22854   if test "x$has_colon" = x; then
22855     # Not in mixed or Windows style, start by that.
22856     new_path=`cmd //c echo $path`
22857   fi
22858 
22859 
22860   input_path="$new_path"
22861   # Check if we need to convert this using DOS-style short mode. If the path
22862   # contains just simple characters, use it. Otherwise (spaces, weird characters),
22863   # take no chances and rewrite it.
22864   # Note: m4 eats our [], so we need to use [ and ] instead.
22865   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
22866   if test "x$has_forbidden_chars" != x; then
22867     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
22868     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
22869   fi
22870 
22871 
22872   windows_path="$new_path"
22873   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22874     unix_path=`$CYGPATH -u "$windows_path"`
22875     new_path="$unix_path"
22876   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22877     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22878     new_path="$unix_path"
22879   fi
22880 
22881   if test "x$path" != "x$new_path"; then
22882     BOOT_JDK="$new_path"
22883     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
22884 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
22885   fi
22886 
22887   # Save the first 10 bytes of this path to the storage, so fixpath can work.
22888   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
22889 
22890     else
22891       # We're on a unix platform. Hooray! :)
22892       path="$BOOT_JDK"
22893       has_space=`$ECHO "$path" | $GREP " "`
22894       if test "x$has_space" != x; then
22895         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
22896 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
22897         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
22898       fi
22899 
22900       # Use eval to expand a potential ~
22901       eval path="$path"
22902       if test ! -f "$path" && test ! -d "$path"; then
22903         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
22904       fi
22905 
22906       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
22907     fi
22908   fi
22909 
22910             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
22911 $as_echo_n "checking for Boot JDK... " >&6; }
22912             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
22913 $as_echo "$BOOT_JDK" >&6; }
22914             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
22915 $as_echo_n "checking Boot JDK version... " >&6; }
22916             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
22917             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
22918 $as_echo "$BOOT_JDK_VERSION" >&6; }
22919           fi # end check jdk version
22920         fi # end check javac
22921       fi # end check java
22922     fi # end check boot jdk found
22923   fi
22924 
22925 
22926   if test "x$BOOT_JDK_FOUND" = xno; then
22927     # Now execute the test
22928 
22929   if test "x$PROGRAMFILES" != x; then
22930     VIRTUAL_DIR="$PROGRAMFILES/Java"
22931 
22932   windows_path="$VIRTUAL_DIR"
22933   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22934     unix_path=`$CYGPATH -u "$windows_path"`
22935     VIRTUAL_DIR="$unix_path"
22936   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
22937     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
22938     VIRTUAL_DIR="$unix_path"
22939   fi
22940 
22941 
22942   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
22943   BOOT_JDK_SUFFIX=""
22944   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
22945   if test "x$ALL_JDKS_FOUND" != x; then
22946     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
22947 
22948   if test "x$BOOT_JDK_FOUND" = xno; then
22949     # Now execute the test
22950 
22951         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
22952         if test -d "$BOOT_JDK"; then
22953           BOOT_JDK_FOUND=maybe
22954           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
22955 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
22956         fi
22957 
22958 
22959     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
22960     if test "x$BOOT_JDK_FOUND" = xmaybe; then
22961       # Do we have a bin/java?
22962       if test ! -x "$BOOT_JDK/bin/java"; then
22963         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
22964 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
22965         BOOT_JDK_FOUND=no
22966       else
22967         # Do we have a bin/javac?
22968         if test ! -x "$BOOT_JDK/bin/javac"; then
22969           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
22970 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
22971           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
22972 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
22973           BOOT_JDK_FOUND=no
22974         else
22975           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
22976           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
22977 
22978           # Extra M4 quote needed to protect [] in grep expression.
22979           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
22980           if test "x$FOUND_CORRECT_VERSION" = x; then
22981             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
22982 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
22983             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
22984 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
22985             BOOT_JDK_FOUND=no
22986           else
22987             # We're done! :-)
22988             BOOT_JDK_FOUND=yes
22989 
22990   # Only process if variable expands to non-empty
22991 
22992   if test "x$BOOT_JDK" != x; then
22993     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
22994 
22995   # Input might be given as Windows format, start by converting to
22996   # unix format.
22997   path="$BOOT_JDK"
22998   new_path=`$CYGPATH -u "$path"`
22999 
23000   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23001   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23002   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23003   # "foo.exe" is OK but "foo" is an error.
23004   #
23005   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23006   # It is also a way to make sure we got the proper file name for the real test later on.
23007   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23008   if test "x$test_shortpath" = x; then
23009     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23010 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23011     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23012   fi
23013 
23014   # Call helper function which possibly converts this using DOS-style short mode.
23015   # If so, the updated path is stored in $new_path.
23016 
23017   input_path="$new_path"
23018   # Check if we need to convert this using DOS-style short mode. If the path
23019   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23020   # take no chances and rewrite it.
23021   # Note: m4 eats our [], so we need to use [ and ] instead.
23022   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23023   if test "x$has_forbidden_chars" != x; then
23024     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23025     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23026     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23027     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23028       # Going to short mode and back again did indeed matter. Since short mode is
23029       # case insensitive, let's make it lowercase to improve readability.
23030       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23031       # Now convert it back to Unix-stile (cygpath)
23032       input_path=`$CYGPATH -u "$shortmode_path"`
23033       new_path="$input_path"
23034     fi
23035   fi
23036 
23037   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23038   if test "x$test_cygdrive_prefix" = x; then
23039     # As a simple fix, exclude /usr/bin since it's not a real path.
23040     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23041       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23042       # a path prefixed by /cygdrive for fixpath to work.
23043       new_path="$CYGWIN_ROOT_PATH$input_path"
23044     fi
23045   fi
23046 
23047 
23048   if test "x$path" != "x$new_path"; then
23049     BOOT_JDK="$new_path"
23050     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23051 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23052   fi
23053 
23054     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23055 
23056   path="$BOOT_JDK"
23057   has_colon=`$ECHO $path | $GREP ^.:`
23058   new_path="$path"
23059   if test "x$has_colon" = x; then
23060     # Not in mixed or Windows style, start by that.
23061     new_path=`cmd //c echo $path`
23062   fi
23063 
23064 
23065   input_path="$new_path"
23066   # Check if we need to convert this using DOS-style short mode. If the path
23067   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23068   # take no chances and rewrite it.
23069   # Note: m4 eats our [], so we need to use [ and ] instead.
23070   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23071   if test "x$has_forbidden_chars" != x; then
23072     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23073     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23074   fi
23075 
23076 
23077   windows_path="$new_path"
23078   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23079     unix_path=`$CYGPATH -u "$windows_path"`
23080     new_path="$unix_path"
23081   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23082     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23083     new_path="$unix_path"
23084   fi
23085 
23086   if test "x$path" != "x$new_path"; then
23087     BOOT_JDK="$new_path"
23088     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23089 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23090   fi
23091 
23092   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23093   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23094 
23095     else
23096       # We're on a unix platform. Hooray! :)
23097       path="$BOOT_JDK"
23098       has_space=`$ECHO "$path" | $GREP " "`
23099       if test "x$has_space" != x; then
23100         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23101 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23102         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23103       fi
23104 
23105       # Use eval to expand a potential ~
23106       eval path="$path"
23107       if test ! -f "$path" && test ! -d "$path"; then
23108         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23109       fi
23110 
23111       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23112     fi
23113   fi
23114 
23115             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23116 $as_echo_n "checking for Boot JDK... " >&6; }
23117             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23118 $as_echo "$BOOT_JDK" >&6; }
23119             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23120 $as_echo_n "checking Boot JDK version... " >&6; }
23121             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23122             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23123 $as_echo "$BOOT_JDK_VERSION" >&6; }
23124           fi # end check jdk version
23125         fi # end check javac
23126       fi # end check java
23127     fi # end check boot jdk found
23128   fi
23129 
23130     done
23131   fi
23132 
23133   fi
23134 
23135 
23136     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23137     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23138       # Do we have a bin/java?
23139       if test ! -x "$BOOT_JDK/bin/java"; then
23140         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23141 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23142         BOOT_JDK_FOUND=no
23143       else
23144         # Do we have a bin/javac?
23145         if test ! -x "$BOOT_JDK/bin/javac"; then
23146           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23147 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23148           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23149 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23150           BOOT_JDK_FOUND=no
23151         else
23152           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23153           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23154 
23155           # Extra M4 quote needed to protect [] in grep expression.
23156           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23157           if test "x$FOUND_CORRECT_VERSION" = x; then
23158             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23159 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23160             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23161 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23162             BOOT_JDK_FOUND=no
23163           else
23164             # We're done! :-)
23165             BOOT_JDK_FOUND=yes
23166 
23167   # Only process if variable expands to non-empty
23168 
23169   if test "x$BOOT_JDK" != x; then
23170     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23171 
23172   # Input might be given as Windows format, start by converting to
23173   # unix format.
23174   path="$BOOT_JDK"
23175   new_path=`$CYGPATH -u "$path"`
23176 
23177   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23178   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23179   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23180   # "foo.exe" is OK but "foo" is an error.
23181   #
23182   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23183   # It is also a way to make sure we got the proper file name for the real test later on.
23184   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23185   if test "x$test_shortpath" = x; then
23186     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23187 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23188     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23189   fi
23190 
23191   # Call helper function which possibly converts this using DOS-style short mode.
23192   # If so, the updated path is stored in $new_path.
23193 
23194   input_path="$new_path"
23195   # Check if we need to convert this using DOS-style short mode. If the path
23196   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23197   # take no chances and rewrite it.
23198   # Note: m4 eats our [], so we need to use [ and ] instead.
23199   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23200   if test "x$has_forbidden_chars" != x; then
23201     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23202     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23203     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23204     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23205       # Going to short mode and back again did indeed matter. Since short mode is
23206       # case insensitive, let's make it lowercase to improve readability.
23207       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23208       # Now convert it back to Unix-stile (cygpath)
23209       input_path=`$CYGPATH -u "$shortmode_path"`
23210       new_path="$input_path"
23211     fi
23212   fi
23213 
23214   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23215   if test "x$test_cygdrive_prefix" = x; then
23216     # As a simple fix, exclude /usr/bin since it's not a real path.
23217     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23218       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23219       # a path prefixed by /cygdrive for fixpath to work.
23220       new_path="$CYGWIN_ROOT_PATH$input_path"
23221     fi
23222   fi
23223 
23224 
23225   if test "x$path" != "x$new_path"; then
23226     BOOT_JDK="$new_path"
23227     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23228 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23229   fi
23230 
23231     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23232 
23233   path="$BOOT_JDK"
23234   has_colon=`$ECHO $path | $GREP ^.:`
23235   new_path="$path"
23236   if test "x$has_colon" = x; then
23237     # Not in mixed or Windows style, start by that.
23238     new_path=`cmd //c echo $path`
23239   fi
23240 
23241 
23242   input_path="$new_path"
23243   # Check if we need to convert this using DOS-style short mode. If the path
23244   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23245   # take no chances and rewrite it.
23246   # Note: m4 eats our [], so we need to use [ and ] instead.
23247   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23248   if test "x$has_forbidden_chars" != x; then
23249     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23250     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23251   fi
23252 
23253 
23254   windows_path="$new_path"
23255   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23256     unix_path=`$CYGPATH -u "$windows_path"`
23257     new_path="$unix_path"
23258   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23259     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23260     new_path="$unix_path"
23261   fi
23262 
23263   if test "x$path" != "x$new_path"; then
23264     BOOT_JDK="$new_path"
23265     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23266 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23267   fi
23268 
23269   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23270   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23271 
23272     else
23273       # We're on a unix platform. Hooray! :)
23274       path="$BOOT_JDK"
23275       has_space=`$ECHO "$path" | $GREP " "`
23276       if test "x$has_space" != x; then
23277         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23278 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23279         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23280       fi
23281 
23282       # Use eval to expand a potential ~
23283       eval path="$path"
23284       if test ! -f "$path" && test ! -d "$path"; then
23285         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23286       fi
23287 
23288       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23289     fi
23290   fi
23291 
23292             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23293 $as_echo_n "checking for Boot JDK... " >&6; }
23294             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23295 $as_echo "$BOOT_JDK" >&6; }
23296             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23297 $as_echo_n "checking Boot JDK version... " >&6; }
23298             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23299             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23300 $as_echo "$BOOT_JDK_VERSION" >&6; }
23301           fi # end check jdk version
23302         fi # end check javac
23303       fi # end check java
23304     fi # end check boot jdk found
23305   fi
23306 
23307 
23308   if test "x$BOOT_JDK_FOUND" = xno; then
23309     # Now execute the test
23310 
23311   if test "x$ProgramFiles" != x; then
23312     VIRTUAL_DIR="$ProgramFiles/Java"
23313 
23314   windows_path="$VIRTUAL_DIR"
23315   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23316     unix_path=`$CYGPATH -u "$windows_path"`
23317     VIRTUAL_DIR="$unix_path"
23318   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23319     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23320     VIRTUAL_DIR="$unix_path"
23321   fi
23322 
23323 
23324   BOOT_JDK_PREFIX="$VIRTUAL_DIR"
23325   BOOT_JDK_SUFFIX=""
23326   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23327   if test "x$ALL_JDKS_FOUND" != x; then
23328     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23329 
23330   if test "x$BOOT_JDK_FOUND" = xno; then
23331     # Now execute the test
23332 
23333         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23334         if test -d "$BOOT_JDK"; then
23335           BOOT_JDK_FOUND=maybe
23336           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23337 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23338         fi
23339 
23340 
23341     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23342     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23343       # Do we have a bin/java?
23344       if test ! -x "$BOOT_JDK/bin/java"; then
23345         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23346 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23347         BOOT_JDK_FOUND=no
23348       else
23349         # Do we have a bin/javac?
23350         if test ! -x "$BOOT_JDK/bin/javac"; then
23351           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23352 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23353           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23354 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23355           BOOT_JDK_FOUND=no
23356         else
23357           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23358           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23359 
23360           # Extra M4 quote needed to protect [] in grep expression.
23361           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23362           if test "x$FOUND_CORRECT_VERSION" = x; then
23363             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23364 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23365             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23366 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23367             BOOT_JDK_FOUND=no
23368           else
23369             # We're done! :-)
23370             BOOT_JDK_FOUND=yes
23371 
23372   # Only process if variable expands to non-empty
23373 
23374   if test "x$BOOT_JDK" != x; then
23375     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23376 
23377   # Input might be given as Windows format, start by converting to
23378   # unix format.
23379   path="$BOOT_JDK"
23380   new_path=`$CYGPATH -u "$path"`
23381 
23382   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23383   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23384   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23385   # "foo.exe" is OK but "foo" is an error.
23386   #
23387   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23388   # It is also a way to make sure we got the proper file name for the real test later on.
23389   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23390   if test "x$test_shortpath" = x; then
23391     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23392 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23393     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23394   fi
23395 
23396   # Call helper function which possibly converts this using DOS-style short mode.
23397   # If so, the updated path is stored in $new_path.
23398 
23399   input_path="$new_path"
23400   # Check if we need to convert this using DOS-style short mode. If the path
23401   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23402   # take no chances and rewrite it.
23403   # Note: m4 eats our [], so we need to use [ and ] instead.
23404   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23405   if test "x$has_forbidden_chars" != x; then
23406     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23407     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23408     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23409     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23410       # Going to short mode and back again did indeed matter. Since short mode is
23411       # case insensitive, let's make it lowercase to improve readability.
23412       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23413       # Now convert it back to Unix-stile (cygpath)
23414       input_path=`$CYGPATH -u "$shortmode_path"`
23415       new_path="$input_path"
23416     fi
23417   fi
23418 
23419   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23420   if test "x$test_cygdrive_prefix" = x; then
23421     # As a simple fix, exclude /usr/bin since it's not a real path.
23422     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23423       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23424       # a path prefixed by /cygdrive for fixpath to work.
23425       new_path="$CYGWIN_ROOT_PATH$input_path"
23426     fi
23427   fi
23428 
23429 
23430   if test "x$path" != "x$new_path"; then
23431     BOOT_JDK="$new_path"
23432     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23433 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23434   fi
23435 
23436     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23437 
23438   path="$BOOT_JDK"
23439   has_colon=`$ECHO $path | $GREP ^.:`
23440   new_path="$path"
23441   if test "x$has_colon" = x; then
23442     # Not in mixed or Windows style, start by that.
23443     new_path=`cmd //c echo $path`
23444   fi
23445 
23446 
23447   input_path="$new_path"
23448   # Check if we need to convert this using DOS-style short mode. If the path
23449   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23450   # take no chances and rewrite it.
23451   # Note: m4 eats our [], so we need to use [ and ] instead.
23452   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23453   if test "x$has_forbidden_chars" != x; then
23454     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23455     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23456   fi
23457 
23458 
23459   windows_path="$new_path"
23460   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23461     unix_path=`$CYGPATH -u "$windows_path"`
23462     new_path="$unix_path"
23463   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23464     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23465     new_path="$unix_path"
23466   fi
23467 
23468   if test "x$path" != "x$new_path"; then
23469     BOOT_JDK="$new_path"
23470     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23471 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23472   fi
23473 
23474   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23475   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23476 
23477     else
23478       # We're on a unix platform. Hooray! :)
23479       path="$BOOT_JDK"
23480       has_space=`$ECHO "$path" | $GREP " "`
23481       if test "x$has_space" != x; then
23482         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23483 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23484         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23485       fi
23486 
23487       # Use eval to expand a potential ~
23488       eval path="$path"
23489       if test ! -f "$path" && test ! -d "$path"; then
23490         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23491       fi
23492 
23493       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23494     fi
23495   fi
23496 
23497             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23498 $as_echo_n "checking for Boot JDK... " >&6; }
23499             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23500 $as_echo "$BOOT_JDK" >&6; }
23501             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23502 $as_echo_n "checking Boot JDK version... " >&6; }
23503             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23504             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23505 $as_echo "$BOOT_JDK_VERSION" >&6; }
23506           fi # end check jdk version
23507         fi # end check javac
23508       fi # end check java
23509     fi # end check boot jdk found
23510   fi
23511 
23512     done
23513   fi
23514 
23515   fi
23516 
23517 
23518     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23519     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23520       # Do we have a bin/java?
23521       if test ! -x "$BOOT_JDK/bin/java"; then
23522         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23523 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23524         BOOT_JDK_FOUND=no
23525       else
23526         # Do we have a bin/javac?
23527         if test ! -x "$BOOT_JDK/bin/javac"; then
23528           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23529 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23530           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23531 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23532           BOOT_JDK_FOUND=no
23533         else
23534           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23535           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23536 
23537           # Extra M4 quote needed to protect [] in grep expression.
23538           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23539           if test "x$FOUND_CORRECT_VERSION" = x; then
23540             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23541 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23542             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23543 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23544             BOOT_JDK_FOUND=no
23545           else
23546             # We're done! :-)
23547             BOOT_JDK_FOUND=yes
23548 
23549   # Only process if variable expands to non-empty
23550 
23551   if test "x$BOOT_JDK" != x; then
23552     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23553 
23554   # Input might be given as Windows format, start by converting to
23555   # unix format.
23556   path="$BOOT_JDK"
23557   new_path=`$CYGPATH -u "$path"`
23558 
23559   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23560   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23561   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23562   # "foo.exe" is OK but "foo" is an error.
23563   #
23564   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23565   # It is also a way to make sure we got the proper file name for the real test later on.
23566   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23567   if test "x$test_shortpath" = x; then
23568     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23569 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23570     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23571   fi
23572 
23573   # Call helper function which possibly converts this using DOS-style short mode.
23574   # If so, the updated path is stored in $new_path.
23575 
23576   input_path="$new_path"
23577   # Check if we need to convert this using DOS-style short mode. If the path
23578   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23579   # take no chances and rewrite it.
23580   # Note: m4 eats our [], so we need to use [ and ] instead.
23581   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23582   if test "x$has_forbidden_chars" != x; then
23583     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23584     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23585     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23586     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23587       # Going to short mode and back again did indeed matter. Since short mode is
23588       # case insensitive, let's make it lowercase to improve readability.
23589       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23590       # Now convert it back to Unix-stile (cygpath)
23591       input_path=`$CYGPATH -u "$shortmode_path"`
23592       new_path="$input_path"
23593     fi
23594   fi
23595 
23596   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23597   if test "x$test_cygdrive_prefix" = x; then
23598     # As a simple fix, exclude /usr/bin since it's not a real path.
23599     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23600       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23601       # a path prefixed by /cygdrive for fixpath to work.
23602       new_path="$CYGWIN_ROOT_PATH$input_path"
23603     fi
23604   fi
23605 
23606 
23607   if test "x$path" != "x$new_path"; then
23608     BOOT_JDK="$new_path"
23609     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23610 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23611   fi
23612 
23613     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23614 
23615   path="$BOOT_JDK"
23616   has_colon=`$ECHO $path | $GREP ^.:`
23617   new_path="$path"
23618   if test "x$has_colon" = x; then
23619     # Not in mixed or Windows style, start by that.
23620     new_path=`cmd //c echo $path`
23621   fi
23622 
23623 
23624   input_path="$new_path"
23625   # Check if we need to convert this using DOS-style short mode. If the path
23626   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23627   # take no chances and rewrite it.
23628   # Note: m4 eats our [], so we need to use [ and ] instead.
23629   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23630   if test "x$has_forbidden_chars" != x; then
23631     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23632     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23633   fi
23634 
23635 
23636   windows_path="$new_path"
23637   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23638     unix_path=`$CYGPATH -u "$windows_path"`
23639     new_path="$unix_path"
23640   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23641     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23642     new_path="$unix_path"
23643   fi
23644 
23645   if test "x$path" != "x$new_path"; then
23646     BOOT_JDK="$new_path"
23647     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23648 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23649   fi
23650 
23651   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23652   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23653 
23654     else
23655       # We're on a unix platform. Hooray! :)
23656       path="$BOOT_JDK"
23657       has_space=`$ECHO "$path" | $GREP " "`
23658       if test "x$has_space" != x; then
23659         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23660 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23661         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23662       fi
23663 
23664       # Use eval to expand a potential ~
23665       eval path="$path"
23666       if test ! -f "$path" && test ! -d "$path"; then
23667         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23668       fi
23669 
23670       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23671     fi
23672   fi
23673 
23674             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23675 $as_echo_n "checking for Boot JDK... " >&6; }
23676             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23677 $as_echo "$BOOT_JDK" >&6; }
23678             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23679 $as_echo_n "checking Boot JDK version... " >&6; }
23680             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23681             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23682 $as_echo "$BOOT_JDK_VERSION" >&6; }
23683           fi # end check jdk version
23684         fi # end check javac
23685       fi # end check java
23686     fi # end check boot jdk found
23687   fi
23688 
23689 
23690   if test "x$BOOT_JDK_FOUND" = xno; then
23691     # Now execute the test
23692 
23693   BOOT_JDK_PREFIX="/cygdrive/c/Program Files/Java"
23694   BOOT_JDK_SUFFIX=""
23695   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
23696   if test "x$ALL_JDKS_FOUND" != x; then
23697     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
23698 
23699   if test "x$BOOT_JDK_FOUND" = xno; then
23700     # Now execute the test
23701 
23702         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
23703         if test -d "$BOOT_JDK"; then
23704           BOOT_JDK_FOUND=maybe
23705           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
23706 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
23707         fi
23708 
23709 
23710     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23711     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23712       # Do we have a bin/java?
23713       if test ! -x "$BOOT_JDK/bin/java"; then
23714         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23715 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23716         BOOT_JDK_FOUND=no
23717       else
23718         # Do we have a bin/javac?
23719         if test ! -x "$BOOT_JDK/bin/javac"; then
23720           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23721 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23722           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23723 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23724           BOOT_JDK_FOUND=no
23725         else
23726           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23727           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23728 
23729           # Extra M4 quote needed to protect [] in grep expression.
23730           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23731           if test "x$FOUND_CORRECT_VERSION" = x; then
23732             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23733 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23734             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23735 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23736             BOOT_JDK_FOUND=no
23737           else
23738             # We're done! :-)
23739             BOOT_JDK_FOUND=yes
23740 
23741   # Only process if variable expands to non-empty
23742 
23743   if test "x$BOOT_JDK" != x; then
23744     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23745 
23746   # Input might be given as Windows format, start by converting to
23747   # unix format.
23748   path="$BOOT_JDK"
23749   new_path=`$CYGPATH -u "$path"`
23750 
23751   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23752   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23753   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23754   # "foo.exe" is OK but "foo" is an error.
23755   #
23756   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23757   # It is also a way to make sure we got the proper file name for the real test later on.
23758   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23759   if test "x$test_shortpath" = x; then
23760     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23761 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23762     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23763   fi
23764 
23765   # Call helper function which possibly converts this using DOS-style short mode.
23766   # If so, the updated path is stored in $new_path.
23767 
23768   input_path="$new_path"
23769   # Check if we need to convert this using DOS-style short mode. If the path
23770   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23771   # take no chances and rewrite it.
23772   # Note: m4 eats our [], so we need to use [ and ] instead.
23773   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23774   if test "x$has_forbidden_chars" != x; then
23775     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23776     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23777     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23778     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23779       # Going to short mode and back again did indeed matter. Since short mode is
23780       # case insensitive, let's make it lowercase to improve readability.
23781       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23782       # Now convert it back to Unix-stile (cygpath)
23783       input_path=`$CYGPATH -u "$shortmode_path"`
23784       new_path="$input_path"
23785     fi
23786   fi
23787 
23788   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23789   if test "x$test_cygdrive_prefix" = x; then
23790     # As a simple fix, exclude /usr/bin since it's not a real path.
23791     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23792       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23793       # a path prefixed by /cygdrive for fixpath to work.
23794       new_path="$CYGWIN_ROOT_PATH$input_path"
23795     fi
23796   fi
23797 
23798 
23799   if test "x$path" != "x$new_path"; then
23800     BOOT_JDK="$new_path"
23801     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23802 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23803   fi
23804 
23805     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23806 
23807   path="$BOOT_JDK"
23808   has_colon=`$ECHO $path | $GREP ^.:`
23809   new_path="$path"
23810   if test "x$has_colon" = x; then
23811     # Not in mixed or Windows style, start by that.
23812     new_path=`cmd //c echo $path`
23813   fi
23814 
23815 
23816   input_path="$new_path"
23817   # Check if we need to convert this using DOS-style short mode. If the path
23818   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23819   # take no chances and rewrite it.
23820   # Note: m4 eats our [], so we need to use [ and ] instead.
23821   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23822   if test "x$has_forbidden_chars" != x; then
23823     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23824     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23825   fi
23826 
23827 
23828   windows_path="$new_path"
23829   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23830     unix_path=`$CYGPATH -u "$windows_path"`
23831     new_path="$unix_path"
23832   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23833     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
23834     new_path="$unix_path"
23835   fi
23836 
23837   if test "x$path" != "x$new_path"; then
23838     BOOT_JDK="$new_path"
23839     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23840 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23841   fi
23842 
23843   # Save the first 10 bytes of this path to the storage, so fixpath can work.
23844   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
23845 
23846     else
23847       # We're on a unix platform. Hooray! :)
23848       path="$BOOT_JDK"
23849       has_space=`$ECHO "$path" | $GREP " "`
23850       if test "x$has_space" != x; then
23851         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23852 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23853         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
23854       fi
23855 
23856       # Use eval to expand a potential ~
23857       eval path="$path"
23858       if test ! -f "$path" && test ! -d "$path"; then
23859         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
23860       fi
23861 
23862       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
23863     fi
23864   fi
23865 
23866             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
23867 $as_echo_n "checking for Boot JDK... " >&6; }
23868             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
23869 $as_echo "$BOOT_JDK" >&6; }
23870             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
23871 $as_echo_n "checking Boot JDK version... " >&6; }
23872             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
23873             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
23874 $as_echo "$BOOT_JDK_VERSION" >&6; }
23875           fi # end check jdk version
23876         fi # end check javac
23877       fi # end check java
23878     fi # end check boot jdk found
23879   fi
23880 
23881     done
23882   fi
23883 
23884 
23885     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
23886     if test "x$BOOT_JDK_FOUND" = xmaybe; then
23887       # Do we have a bin/java?
23888       if test ! -x "$BOOT_JDK/bin/java"; then
23889         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
23890 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
23891         BOOT_JDK_FOUND=no
23892       else
23893         # Do we have a bin/javac?
23894         if test ! -x "$BOOT_JDK/bin/javac"; then
23895           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
23896 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
23897           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
23898 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
23899           BOOT_JDK_FOUND=no
23900         else
23901           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
23902           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
23903 
23904           # Extra M4 quote needed to protect [] in grep expression.
23905           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
23906           if test "x$FOUND_CORRECT_VERSION" = x; then
23907             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
23908 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
23909             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
23910 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
23911             BOOT_JDK_FOUND=no
23912           else
23913             # We're done! :-)
23914             BOOT_JDK_FOUND=yes
23915 
23916   # Only process if variable expands to non-empty
23917 
23918   if test "x$BOOT_JDK" != x; then
23919     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
23920 
23921   # Input might be given as Windows format, start by converting to
23922   # unix format.
23923   path="$BOOT_JDK"
23924   new_path=`$CYGPATH -u "$path"`
23925 
23926   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
23927   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
23928   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
23929   # "foo.exe" is OK but "foo" is an error.
23930   #
23931   # This test is therefore slightly more accurate than "test -f" to check for file precense.
23932   # It is also a way to make sure we got the proper file name for the real test later on.
23933   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
23934   if test "x$test_shortpath" = x; then
23935     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
23936 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
23937     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
23938   fi
23939 
23940   # Call helper function which possibly converts this using DOS-style short mode.
23941   # If so, the updated path is stored in $new_path.
23942 
23943   input_path="$new_path"
23944   # Check if we need to convert this using DOS-style short mode. If the path
23945   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23946   # take no chances and rewrite it.
23947   # Note: m4 eats our [], so we need to use [ and ] instead.
23948   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
23949   if test "x$has_forbidden_chars" != x; then
23950     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23951     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
23952     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
23953     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
23954       # Going to short mode and back again did indeed matter. Since short mode is
23955       # case insensitive, let's make it lowercase to improve readability.
23956       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
23957       # Now convert it back to Unix-stile (cygpath)
23958       input_path=`$CYGPATH -u "$shortmode_path"`
23959       new_path="$input_path"
23960     fi
23961   fi
23962 
23963   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
23964   if test "x$test_cygdrive_prefix" = x; then
23965     # As a simple fix, exclude /usr/bin since it's not a real path.
23966     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
23967       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
23968       # a path prefixed by /cygdrive for fixpath to work.
23969       new_path="$CYGWIN_ROOT_PATH$input_path"
23970     fi
23971   fi
23972 
23973 
23974   if test "x$path" != "x$new_path"; then
23975     BOOT_JDK="$new_path"
23976     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
23977 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
23978   fi
23979 
23980     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
23981 
23982   path="$BOOT_JDK"
23983   has_colon=`$ECHO $path | $GREP ^.:`
23984   new_path="$path"
23985   if test "x$has_colon" = x; then
23986     # Not in mixed or Windows style, start by that.
23987     new_path=`cmd //c echo $path`
23988   fi
23989 
23990 
23991   input_path="$new_path"
23992   # Check if we need to convert this using DOS-style short mode. If the path
23993   # contains just simple characters, use it. Otherwise (spaces, weird characters),
23994   # take no chances and rewrite it.
23995   # Note: m4 eats our [], so we need to use [ and ] instead.
23996   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
23997   if test "x$has_forbidden_chars" != x; then
23998     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
23999     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24000   fi
24001 
24002 
24003   windows_path="$new_path"
24004   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24005     unix_path=`$CYGPATH -u "$windows_path"`
24006     new_path="$unix_path"
24007   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24008     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24009     new_path="$unix_path"
24010   fi
24011 
24012   if test "x$path" != "x$new_path"; then
24013     BOOT_JDK="$new_path"
24014     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24015 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24016   fi
24017 
24018   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24019   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24020 
24021     else
24022       # We're on a unix platform. Hooray! :)
24023       path="$BOOT_JDK"
24024       has_space=`$ECHO "$path" | $GREP " "`
24025       if test "x$has_space" != x; then
24026         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24027 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24028         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24029       fi
24030 
24031       # Use eval to expand a potential ~
24032       eval path="$path"
24033       if test ! -f "$path" && test ! -d "$path"; then
24034         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24035       fi
24036 
24037       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24038     fi
24039   fi
24040 
24041             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24042 $as_echo_n "checking for Boot JDK... " >&6; }
24043             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24044 $as_echo "$BOOT_JDK" >&6; }
24045             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24046 $as_echo_n "checking Boot JDK version... " >&6; }
24047             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24048             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24049 $as_echo "$BOOT_JDK_VERSION" >&6; }
24050           fi # end check jdk version
24051         fi # end check javac
24052       fi # end check java
24053     fi # end check boot jdk found
24054   fi
24055 
24056   elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
24057 
24058   if test "x$BOOT_JDK_FOUND" = xno; then
24059     # Now execute the test
24060 
24061   BOOT_JDK_PREFIX="/Library/Java/JavaVirtualMachines"
24062   BOOT_JDK_SUFFIX="/Contents/Home"
24063   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24064   if test "x$ALL_JDKS_FOUND" != x; then
24065     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24066 
24067   if test "x$BOOT_JDK_FOUND" = xno; then
24068     # Now execute the test
24069 
24070         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24071         if test -d "$BOOT_JDK"; then
24072           BOOT_JDK_FOUND=maybe
24073           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24074 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24075         fi
24076 
24077 
24078     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24079     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24080       # Do we have a bin/java?
24081       if test ! -x "$BOOT_JDK/bin/java"; then
24082         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24083 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24084         BOOT_JDK_FOUND=no
24085       else
24086         # Do we have a bin/javac?
24087         if test ! -x "$BOOT_JDK/bin/javac"; then
24088           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24089 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24090           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24091 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24092           BOOT_JDK_FOUND=no
24093         else
24094           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24095           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24096 
24097           # Extra M4 quote needed to protect [] in grep expression.
24098           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24099           if test "x$FOUND_CORRECT_VERSION" = x; then
24100             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24101 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24102             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24103 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24104             BOOT_JDK_FOUND=no
24105           else
24106             # We're done! :-)
24107             BOOT_JDK_FOUND=yes
24108 
24109   # Only process if variable expands to non-empty
24110 
24111   if test "x$BOOT_JDK" != x; then
24112     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24113 
24114   # Input might be given as Windows format, start by converting to
24115   # unix format.
24116   path="$BOOT_JDK"
24117   new_path=`$CYGPATH -u "$path"`
24118 
24119   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24120   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24121   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24122   # "foo.exe" is OK but "foo" is an error.
24123   #
24124   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24125   # It is also a way to make sure we got the proper file name for the real test later on.
24126   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24127   if test "x$test_shortpath" = x; then
24128     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24129 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24130     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24131   fi
24132 
24133   # Call helper function which possibly converts this using DOS-style short mode.
24134   # If so, the updated path is stored in $new_path.
24135 
24136   input_path="$new_path"
24137   # Check if we need to convert this using DOS-style short mode. If the path
24138   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24139   # take no chances and rewrite it.
24140   # Note: m4 eats our [], so we need to use [ and ] instead.
24141   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24142   if test "x$has_forbidden_chars" != x; then
24143     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24144     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24145     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24146     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24147       # Going to short mode and back again did indeed matter. Since short mode is
24148       # case insensitive, let's make it lowercase to improve readability.
24149       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24150       # Now convert it back to Unix-stile (cygpath)
24151       input_path=`$CYGPATH -u "$shortmode_path"`
24152       new_path="$input_path"
24153     fi
24154   fi
24155 
24156   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24157   if test "x$test_cygdrive_prefix" = x; then
24158     # As a simple fix, exclude /usr/bin since it's not a real path.
24159     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24160       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24161       # a path prefixed by /cygdrive for fixpath to work.
24162       new_path="$CYGWIN_ROOT_PATH$input_path"
24163     fi
24164   fi
24165 
24166 
24167   if test "x$path" != "x$new_path"; then
24168     BOOT_JDK="$new_path"
24169     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24170 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24171   fi
24172 
24173     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24174 
24175   path="$BOOT_JDK"
24176   has_colon=`$ECHO $path | $GREP ^.:`
24177   new_path="$path"
24178   if test "x$has_colon" = x; then
24179     # Not in mixed or Windows style, start by that.
24180     new_path=`cmd //c echo $path`
24181   fi
24182 
24183 
24184   input_path="$new_path"
24185   # Check if we need to convert this using DOS-style short mode. If the path
24186   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24187   # take no chances and rewrite it.
24188   # Note: m4 eats our [], so we need to use [ and ] instead.
24189   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24190   if test "x$has_forbidden_chars" != x; then
24191     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24192     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24193   fi
24194 
24195 
24196   windows_path="$new_path"
24197   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24198     unix_path=`$CYGPATH -u "$windows_path"`
24199     new_path="$unix_path"
24200   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24201     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24202     new_path="$unix_path"
24203   fi
24204 
24205   if test "x$path" != "x$new_path"; then
24206     BOOT_JDK="$new_path"
24207     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24208 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24209   fi
24210 
24211   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24212   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24213 
24214     else
24215       # We're on a unix platform. Hooray! :)
24216       path="$BOOT_JDK"
24217       has_space=`$ECHO "$path" | $GREP " "`
24218       if test "x$has_space" != x; then
24219         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24220 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24221         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24222       fi
24223 
24224       # Use eval to expand a potential ~
24225       eval path="$path"
24226       if test ! -f "$path" && test ! -d "$path"; then
24227         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24228       fi
24229 
24230       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24231     fi
24232   fi
24233 
24234             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24235 $as_echo_n "checking for Boot JDK... " >&6; }
24236             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24237 $as_echo "$BOOT_JDK" >&6; }
24238             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24239 $as_echo_n "checking Boot JDK version... " >&6; }
24240             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24241             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24242 $as_echo "$BOOT_JDK_VERSION" >&6; }
24243           fi # end check jdk version
24244         fi # end check javac
24245       fi # end check java
24246     fi # end check boot jdk found
24247   fi
24248 
24249     done
24250   fi
24251 
24252 
24253     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24254     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24255       # Do we have a bin/java?
24256       if test ! -x "$BOOT_JDK/bin/java"; then
24257         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24258 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24259         BOOT_JDK_FOUND=no
24260       else
24261         # Do we have a bin/javac?
24262         if test ! -x "$BOOT_JDK/bin/javac"; then
24263           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24264 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24265           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24266 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24267           BOOT_JDK_FOUND=no
24268         else
24269           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24270           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24271 
24272           # Extra M4 quote needed to protect [] in grep expression.
24273           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24274           if test "x$FOUND_CORRECT_VERSION" = x; then
24275             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24276 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24277             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24278 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24279             BOOT_JDK_FOUND=no
24280           else
24281             # We're done! :-)
24282             BOOT_JDK_FOUND=yes
24283 
24284   # Only process if variable expands to non-empty
24285 
24286   if test "x$BOOT_JDK" != x; then
24287     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24288 
24289   # Input might be given as Windows format, start by converting to
24290   # unix format.
24291   path="$BOOT_JDK"
24292   new_path=`$CYGPATH -u "$path"`
24293 
24294   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24295   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24296   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24297   # "foo.exe" is OK but "foo" is an error.
24298   #
24299   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24300   # It is also a way to make sure we got the proper file name for the real test later on.
24301   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24302   if test "x$test_shortpath" = x; then
24303     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24304 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24305     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24306   fi
24307 
24308   # Call helper function which possibly converts this using DOS-style short mode.
24309   # If so, the updated path is stored in $new_path.
24310 
24311   input_path="$new_path"
24312   # Check if we need to convert this using DOS-style short mode. If the path
24313   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24314   # take no chances and rewrite it.
24315   # Note: m4 eats our [], so we need to use [ and ] instead.
24316   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24317   if test "x$has_forbidden_chars" != x; then
24318     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24319     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24320     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24321     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24322       # Going to short mode and back again did indeed matter. Since short mode is
24323       # case insensitive, let's make it lowercase to improve readability.
24324       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24325       # Now convert it back to Unix-stile (cygpath)
24326       input_path=`$CYGPATH -u "$shortmode_path"`
24327       new_path="$input_path"
24328     fi
24329   fi
24330 
24331   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24332   if test "x$test_cygdrive_prefix" = x; then
24333     # As a simple fix, exclude /usr/bin since it's not a real path.
24334     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24335       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24336       # a path prefixed by /cygdrive for fixpath to work.
24337       new_path="$CYGWIN_ROOT_PATH$input_path"
24338     fi
24339   fi
24340 
24341 
24342   if test "x$path" != "x$new_path"; then
24343     BOOT_JDK="$new_path"
24344     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24345 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24346   fi
24347 
24348     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24349 
24350   path="$BOOT_JDK"
24351   has_colon=`$ECHO $path | $GREP ^.:`
24352   new_path="$path"
24353   if test "x$has_colon" = x; then
24354     # Not in mixed or Windows style, start by that.
24355     new_path=`cmd //c echo $path`
24356   fi
24357 
24358 
24359   input_path="$new_path"
24360   # Check if we need to convert this using DOS-style short mode. If the path
24361   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24362   # take no chances and rewrite it.
24363   # Note: m4 eats our [], so we need to use [ and ] instead.
24364   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24365   if test "x$has_forbidden_chars" != x; then
24366     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24367     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24368   fi
24369 
24370 
24371   windows_path="$new_path"
24372   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24373     unix_path=`$CYGPATH -u "$windows_path"`
24374     new_path="$unix_path"
24375   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24376     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24377     new_path="$unix_path"
24378   fi
24379 
24380   if test "x$path" != "x$new_path"; then
24381     BOOT_JDK="$new_path"
24382     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24383 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24384   fi
24385 
24386   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24387   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24388 
24389     else
24390       # We're on a unix platform. Hooray! :)
24391       path="$BOOT_JDK"
24392       has_space=`$ECHO "$path" | $GREP " "`
24393       if test "x$has_space" != x; then
24394         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24395 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24396         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24397       fi
24398 
24399       # Use eval to expand a potential ~
24400       eval path="$path"
24401       if test ! -f "$path" && test ! -d "$path"; then
24402         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24403       fi
24404 
24405       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24406     fi
24407   fi
24408 
24409             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24410 $as_echo_n "checking for Boot JDK... " >&6; }
24411             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24412 $as_echo "$BOOT_JDK" >&6; }
24413             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24414 $as_echo_n "checking Boot JDK version... " >&6; }
24415             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24416             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24417 $as_echo "$BOOT_JDK_VERSION" >&6; }
24418           fi # end check jdk version
24419         fi # end check javac
24420       fi # end check java
24421     fi # end check boot jdk found
24422   fi
24423 
24424 
24425   if test "x$BOOT_JDK_FOUND" = xno; then
24426     # Now execute the test
24427 
24428   BOOT_JDK_PREFIX="/System/Library/Java/JavaVirtualMachines"
24429   BOOT_JDK_SUFFIX="/Contents/Home"
24430   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24431   if test "x$ALL_JDKS_FOUND" != x; then
24432     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24433 
24434   if test "x$BOOT_JDK_FOUND" = xno; then
24435     # Now execute the test
24436 
24437         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24438         if test -d "$BOOT_JDK"; then
24439           BOOT_JDK_FOUND=maybe
24440           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24441 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24442         fi
24443 
24444 
24445     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24446     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24447       # Do we have a bin/java?
24448       if test ! -x "$BOOT_JDK/bin/java"; then
24449         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24450 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24451         BOOT_JDK_FOUND=no
24452       else
24453         # Do we have a bin/javac?
24454         if test ! -x "$BOOT_JDK/bin/javac"; then
24455           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24456 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24457           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24458 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24459           BOOT_JDK_FOUND=no
24460         else
24461           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24462           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24463 
24464           # Extra M4 quote needed to protect [] in grep expression.
24465           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24466           if test "x$FOUND_CORRECT_VERSION" = x; then
24467             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24468 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24469             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24470 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24471             BOOT_JDK_FOUND=no
24472           else
24473             # We're done! :-)
24474             BOOT_JDK_FOUND=yes
24475 
24476   # Only process if variable expands to non-empty
24477 
24478   if test "x$BOOT_JDK" != x; then
24479     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24480 
24481   # Input might be given as Windows format, start by converting to
24482   # unix format.
24483   path="$BOOT_JDK"
24484   new_path=`$CYGPATH -u "$path"`
24485 
24486   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24487   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24488   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24489   # "foo.exe" is OK but "foo" is an error.
24490   #
24491   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24492   # It is also a way to make sure we got the proper file name for the real test later on.
24493   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24494   if test "x$test_shortpath" = x; then
24495     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24496 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24497     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24498   fi
24499 
24500   # Call helper function which possibly converts this using DOS-style short mode.
24501   # If so, the updated path is stored in $new_path.
24502 
24503   input_path="$new_path"
24504   # Check if we need to convert this using DOS-style short mode. If the path
24505   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24506   # take no chances and rewrite it.
24507   # Note: m4 eats our [], so we need to use [ and ] instead.
24508   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24509   if test "x$has_forbidden_chars" != x; then
24510     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24511     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24512     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24513     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24514       # Going to short mode and back again did indeed matter. Since short mode is
24515       # case insensitive, let's make it lowercase to improve readability.
24516       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24517       # Now convert it back to Unix-stile (cygpath)
24518       input_path=`$CYGPATH -u "$shortmode_path"`
24519       new_path="$input_path"
24520     fi
24521   fi
24522 
24523   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24524   if test "x$test_cygdrive_prefix" = x; then
24525     # As a simple fix, exclude /usr/bin since it's not a real path.
24526     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24527       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24528       # a path prefixed by /cygdrive for fixpath to work.
24529       new_path="$CYGWIN_ROOT_PATH$input_path"
24530     fi
24531   fi
24532 
24533 
24534   if test "x$path" != "x$new_path"; then
24535     BOOT_JDK="$new_path"
24536     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24537 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24538   fi
24539 
24540     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24541 
24542   path="$BOOT_JDK"
24543   has_colon=`$ECHO $path | $GREP ^.:`
24544   new_path="$path"
24545   if test "x$has_colon" = x; then
24546     # Not in mixed or Windows style, start by that.
24547     new_path=`cmd //c echo $path`
24548   fi
24549 
24550 
24551   input_path="$new_path"
24552   # Check if we need to convert this using DOS-style short mode. If the path
24553   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24554   # take no chances and rewrite it.
24555   # Note: m4 eats our [], so we need to use [ and ] instead.
24556   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24557   if test "x$has_forbidden_chars" != x; then
24558     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24559     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24560   fi
24561 
24562 
24563   windows_path="$new_path"
24564   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24565     unix_path=`$CYGPATH -u "$windows_path"`
24566     new_path="$unix_path"
24567   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24568     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24569     new_path="$unix_path"
24570   fi
24571 
24572   if test "x$path" != "x$new_path"; then
24573     BOOT_JDK="$new_path"
24574     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24575 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24576   fi
24577 
24578   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24579   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24580 
24581     else
24582       # We're on a unix platform. Hooray! :)
24583       path="$BOOT_JDK"
24584       has_space=`$ECHO "$path" | $GREP " "`
24585       if test "x$has_space" != x; then
24586         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24587 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24588         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24589       fi
24590 
24591       # Use eval to expand a potential ~
24592       eval path="$path"
24593       if test ! -f "$path" && test ! -d "$path"; then
24594         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24595       fi
24596 
24597       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24598     fi
24599   fi
24600 
24601             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24602 $as_echo_n "checking for Boot JDK... " >&6; }
24603             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24604 $as_echo "$BOOT_JDK" >&6; }
24605             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24606 $as_echo_n "checking Boot JDK version... " >&6; }
24607             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24608             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24609 $as_echo "$BOOT_JDK_VERSION" >&6; }
24610           fi # end check jdk version
24611         fi # end check javac
24612       fi # end check java
24613     fi # end check boot jdk found
24614   fi
24615 
24616     done
24617   fi
24618 
24619 
24620     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24621     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24622       # Do we have a bin/java?
24623       if test ! -x "$BOOT_JDK/bin/java"; then
24624         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24625 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24626         BOOT_JDK_FOUND=no
24627       else
24628         # Do we have a bin/javac?
24629         if test ! -x "$BOOT_JDK/bin/javac"; then
24630           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24631 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24632           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24633 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24634           BOOT_JDK_FOUND=no
24635         else
24636           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24637           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24638 
24639           # Extra M4 quote needed to protect [] in grep expression.
24640           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24641           if test "x$FOUND_CORRECT_VERSION" = x; then
24642             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24643 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24644             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24645 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24646             BOOT_JDK_FOUND=no
24647           else
24648             # We're done! :-)
24649             BOOT_JDK_FOUND=yes
24650 
24651   # Only process if variable expands to non-empty
24652 
24653   if test "x$BOOT_JDK" != x; then
24654     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24655 
24656   # Input might be given as Windows format, start by converting to
24657   # unix format.
24658   path="$BOOT_JDK"
24659   new_path=`$CYGPATH -u "$path"`
24660 
24661   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24662   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24663   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24664   # "foo.exe" is OK but "foo" is an error.
24665   #
24666   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24667   # It is also a way to make sure we got the proper file name for the real test later on.
24668   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24669   if test "x$test_shortpath" = x; then
24670     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24671 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24672     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24673   fi
24674 
24675   # Call helper function which possibly converts this using DOS-style short mode.
24676   # If so, the updated path is stored in $new_path.
24677 
24678   input_path="$new_path"
24679   # Check if we need to convert this using DOS-style short mode. If the path
24680   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24681   # take no chances and rewrite it.
24682   # Note: m4 eats our [], so we need to use [ and ] instead.
24683   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24684   if test "x$has_forbidden_chars" != x; then
24685     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24686     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24687     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24688     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24689       # Going to short mode and back again did indeed matter. Since short mode is
24690       # case insensitive, let's make it lowercase to improve readability.
24691       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24692       # Now convert it back to Unix-stile (cygpath)
24693       input_path=`$CYGPATH -u "$shortmode_path"`
24694       new_path="$input_path"
24695     fi
24696   fi
24697 
24698   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24699   if test "x$test_cygdrive_prefix" = x; then
24700     # As a simple fix, exclude /usr/bin since it's not a real path.
24701     if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
24702       # The path is in a Cygwin special directory (e.g. /home). We need this converted to
24703       # a path prefixed by /cygdrive for fixpath to work.
24704       new_path="$CYGWIN_ROOT_PATH$input_path"
24705     fi
24706   fi
24707 
24708 
24709   if test "x$path" != "x$new_path"; then
24710     BOOT_JDK="$new_path"
24711     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24712 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24713   fi
24714 
24715     elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24716 
24717   path="$BOOT_JDK"
24718   has_colon=`$ECHO $path | $GREP ^.:`
24719   new_path="$path"
24720   if test "x$has_colon" = x; then
24721     # Not in mixed or Windows style, start by that.
24722     new_path=`cmd //c echo $path`
24723   fi
24724 
24725 
24726   input_path="$new_path"
24727   # Check if we need to convert this using DOS-style short mode. If the path
24728   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24729   # take no chances and rewrite it.
24730   # Note: m4 eats our [], so we need to use [ and ] instead.
24731   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
24732   if test "x$has_forbidden_chars" != x; then
24733     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24734     new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24735   fi
24736 
24737 
24738   windows_path="$new_path"
24739   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24740     unix_path=`$CYGPATH -u "$windows_path"`
24741     new_path="$unix_path"
24742   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
24743     unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
24744     new_path="$unix_path"
24745   fi
24746 
24747   if test "x$path" != "x$new_path"; then
24748     BOOT_JDK="$new_path"
24749     { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
24750 $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
24751   fi
24752 
24753   # Save the first 10 bytes of this path to the storage, so fixpath can work.
24754   all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
24755 
24756     else
24757       # We're on a unix platform. Hooray! :)
24758       path="$BOOT_JDK"
24759       has_space=`$ECHO "$path" | $GREP " "`
24760       if test "x$has_space" != x; then
24761         { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24762 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24763         as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
24764       fi
24765 
24766       # Use eval to expand a potential ~
24767       eval path="$path"
24768       if test ! -f "$path" && test ! -d "$path"; then
24769         as_fn_error $? "The path of BOOT_JDK, which resolves as \"$path\", is not found." "$LINENO" 5
24770       fi
24771 
24772       BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
24773     fi
24774   fi
24775 
24776             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
24777 $as_echo_n "checking for Boot JDK... " >&6; }
24778             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
24779 $as_echo "$BOOT_JDK" >&6; }
24780             { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
24781 $as_echo_n "checking Boot JDK version... " >&6; }
24782             BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
24783             { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
24784 $as_echo "$BOOT_JDK_VERSION" >&6; }
24785           fi # end check jdk version
24786         fi # end check javac
24787       fi # end check java
24788     fi # end check boot jdk found
24789   fi
24790 
24791   elif test "x$OPENJDK_TARGET_OS" = xlinux; then
24792 
24793   if test "x$BOOT_JDK_FOUND" = xno; then
24794     # Now execute the test
24795 
24796   BOOT_JDK_PREFIX="/usr/lib/jvm"
24797   BOOT_JDK_SUFFIX=""
24798   ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
24799   if test "x$ALL_JDKS_FOUND" != x; then
24800     for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
24801 
24802   if test "x$BOOT_JDK_FOUND" = xno; then
24803     # Now execute the test
24804 
24805         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
24806         if test -d "$BOOT_JDK"; then
24807           BOOT_JDK_FOUND=maybe
24808           { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
24809 $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
24810         fi
24811 
24812 
24813     # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
24814     if test "x$BOOT_JDK_FOUND" = xmaybe; then
24815       # Do we have a bin/java?
24816       if test ! -x "$BOOT_JDK/bin/java"; then
24817         { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
24818 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
24819         BOOT_JDK_FOUND=no
24820       else
24821         # Do we have a bin/javac?
24822         if test ! -x "$BOOT_JDK/bin/javac"; then
24823           { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
24824 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
24825           { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
24826 $as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
24827           BOOT_JDK_FOUND=no
24828         else
24829           # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
24830           BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | head -n 1`
24831 
24832           # Extra M4 quote needed to protect [] in grep expression.
24833           FOUND_CORRECT_VERSION=`echo $BOOT_JDK_VERSION | grep  '\"1\.[89]\.'`
24834           if test "x$FOUND_CORRECT_VERSION" = x; then
24835             { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
24836 $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
24837             { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 8 or 9)" >&5
24838 $as_echo "$as_me: (Your Boot JDK must be version 8 or 9)" >&6;}
24839             BOOT_JDK_FOUND=no
24840           else
24841             # We're done! :-)
24842             BOOT_JDK_FOUND=yes
24843 
24844   # Only process if variable expands to non-empty
24845 
24846   if test "x$BOOT_JDK" != x; then
24847     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
24848 
24849   # Input might be given as Windows format, start by converting to
24850   # unix format.
24851   path="$BOOT_JDK"
24852   new_path=`$CYGPATH -u "$path"`
24853 
24854   # Cygwin tries to hide some aspects of the Windows file system, such that binaries are
24855   # named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
24856   # the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
24857   # "foo.exe" is OK but "foo" is an error.
24858   #
24859   # This test is therefore slightly more accurate than "test -f" to check for file precense.
24860   # It is also a way to make sure we got the proper file name for the real test later on.
24861   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
24862   if test "x$test_shortpath" = x; then
24863     { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
24864 $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
24865     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
24866   fi
24867 
24868   # Call helper function which possibly converts this using DOS-style short mode.
24869   # If so, the updated path is stored in $new_path.
24870 
24871   input_path="$new_path"
24872   # Check if we need to convert this using DOS-style short mode. If the path
24873   # contains just simple characters, use it. Otherwise (spaces, weird characters),
24874   # take no chances and rewrite it.
24875   # Note: m4 eats our [], so we need to use [ and ] instead.
24876   has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
24877   if test "x$has_forbidden_chars" != x; then
24878     # Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
24879     shortmode_path=`$CYGPATH -s -m -a "$input_path"`
24880     path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
24881     if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
24882       # Going to short mode and back again did indeed matter. Since short mode is
24883       # case insensitive, let's make it lowercase to improve readability.
24884       shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
24885       # Now convert it back to Unix-stile (cygpath)
24886       input_path=`$CYGPATH -u "$shortmode_path"`
24887       new_path="$input_path"
24888     fi
24889   fi
24890 
24891   test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
24892   if test "x$test_cygdrive_prefix" = x; then
24893     # As a simple fix, exclude /usr/bin since it's not a real path.
24894     if test "x`$ECHO $new_path